@ykurilov/agent-chat-flows 0.80.0 → 0.81.0

package/dist/index.js

@@ -57,7 +57,7 @@ import {
   transitionReport,
   withPending,
   withReopen
-} from "./chunk-CZ3EDVYW.js";
+} from "./chunk-7ES2PXNH.js";
 import {
   AGENT_FLOW_FORMAT,
   AGENT_FLOW_FORMAT_VERSION,
@@ -143,14 +143,17 @@ import {
   withoutUndeliveredTouch
 } from "./chunk-RMWVLMGY.js";
 import {
+  FLOW_DELIVERY_EXIT,
   appliedInTime,
   byVersionAndState,
   compareText,
   mappedState,
   migratePending,
   normalizeTime,
-  pendingAdded
-} from "./chunk-DCTRMCGV.js";
+  normalizedDelivery,
+  pendingAdded,
+  sameDelivery
+} from "./chunk-DOKHNTPU.js";
 
 // src/runtime/flow-service-blocks.ts
 var FLOW_SERVICE_BLOCKS = [
@@ -333,7 +336,7 @@ async function previewConfirmedMigration(input, deps) {
 }
 
 // src/runtime/agent-flow.ts
-import { createHash as createHash2, randomUUID as randomUUID4 } from "crypto";
+import { createHash as createHash2, randomUUID as randomUUID5 } from "crypto";
 import {
   ChatNotFoundError as ChatNotFoundError4,
   flowStateCommitter as flowStateCommitter2
@@ -969,122 +972,34 @@ function errorText2(error) {
 
 // src/runtime/flow-timers.ts
 import { randomUUID } from "crypto";
-import { ChatNotFoundError as ChatNotFoundError2, SpendingLimitReachedError } from "@ykurilov/agent-chat-core";
+import { ChatNotFoundError, SpendingLimitReachedError } from "@ykurilov/agent-chat-core";
 
-// src/runtime/flow-delivery.ts
-import { answerText, ChatNotFoundError, deliverableParts } from "@ykurilov/agent-chat-core";
-var FLOW_DELIVERY_EXIT = "@delivery";
-var RETRY_DELAYS_MS = [6e4, 5 * 6e4, 30 * 6e4];
+// src/runtime/flow-lease.ts
 var errorText3 = (error) => error instanceof Error ? error.message : String(error);
-var isoOf = (at) => new Date(at).toISOString();
-var hasContent = (answer) => answer.text.trim() !== "" || answer.parts.some((part) => part.type !== "text");
-function createFlowDelivery(input) {
-  const { runtime } = input;
-  const store = runtime.store;
-  const portOf = (chat) => {
-    if (!input.port) throw new Error("\u0414\u043E\u0441\u0442\u0430\u0432\u043A\u0430 \u0441\u0446\u0435\u043D\u0430\u0440\u0438\u044F \u0441\u043E\u0431\u0440\u0430\u043D\u0430 \u0431\u0435\u0437 \u0441\u043B\u0443\u0436\u0431\u044B \u0447\u0430\u0442\u0430");
-    return input.port(chat);
+function holdLease(input) {
+  const { store, chatId, owner, leaseMs } = input;
+  let lost = false;
+  let renewing = null;
+  const renewNow = async () => {
+    if (lost) return false;
+    if (!await store.renewLease({ chatId, owner, now: input.now().toISOString(), leaseMs })) lost = true;
+    return !lost;
   };
-  async function markUndelivered(ownerId, chatId, messageId) {
-    try {
-      await (await portOf({ ownerId, chatId })).markUndelivered({ ownerId, chatId, messageId });
-    } catch (error) {
-      if (error instanceof ChatNotFoundError) return;
-      runtime.logError(`[\u0441\u0446\u0435\u043D\u0430\u0440\u0438\u0439] \u0447\u0430\u0442=${chatId} \u043F\u043E\u043C\u0435\u0442\u043A\u0430 \xAB\u043D\u0435 \u0434\u043E\u0441\u0442\u0430\u0432\u043B\u0435\u043D\u043E\xBB \u043D\u0435 \u0437\u0430\u043F\u0438\u0441\u0430\u043D\u0430: ${errorText3(error)}`);
-    }
-  }
-  async function blocked(ownerId, chatId) {
-    await store.setDelivery(chatId, null);
-    const pinned = await runtime.chatFlow(ownerId, chatId);
-    if (!pinned || !input.finish) {
-      await store.endChat(chatId, { reason: "blocked", at: isoOf(runtime.now()) });
-      return;
-    }
-    const { values } = await (await portOf({ ownerId, chatId })).getChatState(ownerId, chatId);
-    const at = runtime.now();
-    await input.finish().end({ ownerId, chatId, pinned, run: await runOutsideTurn(runtime, { ownerId, chatId }, pinned.flow, values, at), reason: "blocked", at });
-  }
-  async function settle(message, outcome, counted) {
-    const { ownerId, chatId, messageId } = message;
-    switch (outcome.status) {
-      case "delivered":
-        await store.setDelivery(chatId, null);
-        await input.firstMessages?.()?.record({ ownerId, ...counted });
-        return outcome.status;
-      case "retry": {
-        if (message.attempt > RETRY_DELAYS_MS.length) return settle(message, { status: "failed" }, counted);
-        const delay = outcome.afterMs ?? RETRY_DELAYS_MS[message.attempt - 1];
-        const retryAt = runtime.now() + delay;
-        const reasons = message.reasons.map((reason) => JSON.stringify(reason));
-        await store.setDelivery(chatId, { messageId, attempt: message.attempt + 1, retryAt: isoOf(retryAt), reasons });
-        const record = await store.getChat(chatId);
-        await store.setDue(chatId, { at: isoOf(retryAt), exitId: FLOW_DELIVERY_EXIT, branchHead: record?.dueBranchHead ?? null });
-        return outcome.status;
-      }
-      case "failed":
-        await store.setDelivery(chatId, null);
-        await markUndelivered(ownerId, chatId, messageId);
-        return outcome.status;
-      case "window_closed":
-        await store.setDelivery(chatId, null);
-        await markUndelivered(ownerId, chatId, messageId);
-        await store.setWindowClosed(chatId, true);
-        return outcome.status;
-      case "blocked":
-        await markUndelivered(ownerId, chatId, messageId);
-        await blocked(ownerId, chatId);
-        return outcome.status;
-    }
-  }
-  async function send(message) {
-    const deliver = input.deliver();
-    if (!deliver) throw new Error("\u0423 \u043F\u0440\u0438\u043B\u043E\u0436\u0435\u043D\u0438\u044F \u043D\u0435\u0442 \u0441\u0432\u043E\u0435\u0439 \u0434\u043E\u0441\u0442\u0430\u0432\u043A\u0438 (attach({ deliver }))");
-    try {
-      return await deliver(message);
-    } catch (error) {
-      runtime.logError(`[\u0441\u0446\u0435\u043D\u0430\u0440\u0438\u0439] \u0447\u0430\u0442=${message.chatId} \u0434\u043E\u0441\u0442\u0430\u0432\u043A\u0430 \u0443\u043F\u0430\u043B\u0430: ${errorText3(error)}`);
-      return { status: "retry" };
-    }
-  }
-  async function sendAndSettle(message, counted) {
-    return settle(message, await send(message), counted);
-  }
+  const heartbeat = setInterval(() => {
+    renewing ??= renewNow().then(
+      () => {
+      },
+      (error) => input.logError(`[\u0441\u0446\u0435\u043D\u0430\u0440\u0438\u0439] \u0447\u0430\u0442=${chatId} \u0430\u0440\u0435\u043D\u0434\u0430 \u043D\u0435 \u043F\u0440\u043E\u0434\u043B\u0435\u043D\u0430: ${errorText3(error)}`)
+    ).finally(() => {
+      renewing = null;
+    });
+  }, leaseMs / 3);
+  heartbeat.unref?.();
   return {
-    own: () => Boolean(input.deliver()),
-    send,
-    async afterFirstTurn({ ownerId, chatId, answer, reasons, at, timeZone }) {
-      if (!input.deliver()) {
-        await input.firstMessages?.()?.record({ ownerId, at, timeZone });
-        return null;
-      }
-      if (!answer || answer.status !== "complete" || !hasContent(answer)) return null;
-      return sendAndSettle({ ownerId, chatId, messageId: answer.messageId, text: answer.text, parts: answer.parts, reasons, attempt: 1 }, { at, timeZone });
-    },
-    async retry(record, serverAt) {
-      const pending = record.delivery;
-      if (!pending) return null;
-      const { ownerId, chatId } = record;
-      const { messages } = await (await portOf({ ownerId, chatId })).peekHistory(ownerId, chatId);
-      const answer = messages.find((message) => message.id === pending.messageId);
-      if (!answer) {
-        await store.setDelivery(chatId, null);
-        return null;
-      }
-      const text = answerText(answer.parts);
-      const parts = deliverableParts(answer.parts);
-      const reasons = pending.reasons.map((reason) => JSON.parse(reason));
-      const timeZone = await input.timeZoneOf?.(ownerId, chatId) ?? record.timeZone;
-      return sendAndSettle({ ownerId, chatId, messageId: pending.messageId, text, parts, reasons, attempt: pending.attempt }, { at: serverAt, timeZone });
-    },
-    async report({ chatId, messageId, outcome }) {
-      const record = await store.getChat(chatId);
-      if (!record) return;
-      const { ownerId } = record;
-      if (outcome.status === "delivered" || outcome.status === "retry") return;
-      await markUndelivered(ownerId, chatId, messageId);
-      if (outcome.status === "window_closed") await store.setWindowClosed(chatId, true);
-      if (outcome.status === "blocked") await blocked(ownerId, chatId);
-      else await input.onUndelivered?.({ ownerId, chatId, at: runtime.now() });
+    held: renewNow,
+    async stop() {
+      clearInterval(heartbeat);
+      await renewing;
     }
   };
 }
@@ -1119,7 +1034,7 @@ var TIMER_PARALLEL = 5;
 var DAY_MS = 864e5;
 var DEFAULT_FLOW_SERVER_TURNS_IN_ROW = 50;
 var errorText4 = (error) => error instanceof Error ? error.message : String(error);
-var isoOf2 = (at) => new Date(at).toISOString();
+var isoOf = (at) => new Date(at).toISOString();
 var timerKey = (chatId, exitId, run) => `flow:${chatId}:${exitId}:${run.enteredAt}`;
 async function historyFacts(port, ownerId, chatId, answerId) {
   const { messages } = await port.peekHistory(ownerId, chatId);
@@ -1145,7 +1060,7 @@ function createFlowTimers(input) {
   const fired = (chatId, reason) => {
     for (const onFired of watchers.get(chatId) ?? []) onFired(reason);
   };
-  const dueInput = (due, branchHead, offset) => ({ at: isoOf2(due.at - offset), exitId: due.exitId, branchHead });
+  const dueInput = (due, branchHead, offset) => ({ at: isoOf(due.at - offset), exitId: due.exitId, branchHead });
   async function placeOf2(record, chatPort, run, failedAt) {
     const pausedUntil = record.pausedUntil === null ? null : Date.parse(record.pausedUntil);
     const facts = await historyFacts(chatPort, record.ownerId, record.chatId, run.answerId);
@@ -1170,16 +1085,16 @@ function createFlowTimers(input) {
   function reschedule(request) {
     return oneAtATime(request.chatId, () => rescheduleNow(request));
   }
-  async function recountAfterFailure(ownerId, chatId, failedAt) {
-    const { values } = await (await port({ ownerId, chatId })).getChatState(ownerId, chatId);
-    const run = storedRun(values[FLOW_STATE_KEY]);
-    if (run) await reschedule({ ownerId, chatId, run, branchHead: run.answerId ?? null, failedAt });
-  }
   async function rescheduleNow({ ownerId, chatId, run, branchHead, failedAt }) {
     const record = await store.getChat(chatId);
     if (!record) return;
-    if (record.endedAt !== null) return store.setDue(chatId, null);
-    if (record.delivery) return store.setDue(chatId, { at: record.delivery.retryAt, exitId: FLOW_DELIVERY_EXIT, branchHead });
+    const pending = record.delivery;
+    if (pending) {
+      const due2 = pending.pausedAt === void 0 ? { at: pending.retryAt, exitId: FLOW_DELIVERY_EXIT, branchHead } : null;
+      await store.swapDelivery(chatId, { expected: pending, next: pending, due: due2, freeAt: input.now().toISOString() });
+      return;
+    }
+    if (record.endedAt !== null) return store.setDue(chatId, null, { unlessDelivery: true });
     const flow = await input.flowOf(record);
     const offset = run.timeOffset ?? 0;
     const at = input.now().getTime() + offset;
@@ -1208,7 +1123,7 @@ function createFlowTimers(input) {
       });
     }
     if (applied) await input.onAppliedTransitions?.(applied);
-    await store.setDue(chatId, due && { ...due, branchHead: run.answerId ?? null });
+    await store.setDue(chatId, due && { ...due, branchHead: run.answerId ?? null }, { leaseOwner: owner, unlessDelivery: true });
   }
   async function placeMoved(chatPort, record, flow, run, at, timeZone) {
     const { ownerId, chatId } = record;
@@ -1225,26 +1140,31 @@ function createFlowTimers(input) {
       throw error;
     }
   }
-  async function fire(leased, serverAt) {
-    let record = leased;
+  async function fire(leased, serverAt, lease) {
+    const record = leased;
     const { chatId, ownerId } = record;
+    const setDue = (due2, options = {}) => store.setDue(chatId, due2, { unlessDelivery: true, ...options, leaseOwner: owner });
+    const pending = record.delivery;
+    if (pending && input.delivery) {
+      if (pending.pausedAt !== void 0) return store.setDue(chatId, null, { leaseOwner: owner });
+      if (Date.parse(pending.retryAt) > serverAt) {
+        await store.setDue(chatId, { at: pending.retryAt, exitId: FLOW_DELIVERY_EXIT, branchHead: record.dueBranchHead }, { leaseOwner: owner });
+        return;
+      }
+      if (!await lease.held()) return;
+      await input.delivery().retry(record, serverAt, owner);
+      return;
+    }
+    if (record.endedAt !== null) {
+      await setDue(null);
+      return;
+    }
     const flow = await input.flowOf(record);
     if (!flow) {
       logError(`[\u0441\u0446\u0435\u043D\u0430\u0440\u0438\u0439] \u0447\u0430\u0442=${chatId}: \u0432\u0435\u0440\u0441\u0438\u0438 ${record.flowId}@${record.versionId} \u043D\u0435\u0442 \u0432 \u0445\u0440\u0430\u043D\u0438\u043B\u0438\u0449\u0435, \u0442\u0430\u0439\u043C\u0435\u0440 \u0441\u043D\u044F\u0442`);
-      await store.setDue(chatId, null);
+      await setDue(null);
       return;
     }
-    if (record.delivery && input.delivery) {
-      if (Date.parse(record.delivery.retryAt) > serverAt) {
-        await store.setDue(chatId, { at: record.delivery.retryAt, exitId: FLOW_DELIVERY_EXIT, branchHead: record.dueBranchHead });
-        return;
-      }
-      const outcome2 = await input.delivery().retry(record, serverAt);
-      const after = await store.getChat(chatId);
-      if (!after || after.endedAt !== null || after.delivery) return;
-      if (outcome2 === "failed" || outcome2 === "window_closed") return recountAfterFailure(ownerId, chatId, serverAt);
-      record = after;
-    }
     let chatPort;
     let values;
     let offset;
@@ -1253,7 +1173,7 @@ function createFlowTimers(input) {
       ({ values } = await chatPort.getChatState(ownerId, chatId));
       offset = testChatOffset(await chatPort.getChatData(ownerId, chatId)) ?? 0;
     } catch (error) {
-      if (!(error instanceof ChatNotFoundError2)) throw error;
+      if (!(error instanceof ChatNotFoundError)) throw error;
       await store.deleteChat(chatId);
       return;
     }
@@ -1262,12 +1182,13 @@ function createFlowTimers(input) {
     const { run, context, undelivered } = await placeOf2(record, chatPort, await withApplied(record, flow, chatRun(flow, values, record, at, timeZone), at, timeZone));
     const wake = nextWake(flow, run, at, timeZone, context);
     if (!wake || wake.at > at) {
-      await store.setDue(chatId, wake ? dueInput(wake, run.answerId ?? null, offset) : null);
+      await setDue(wake ? dueInput(wake, run.answerId ?? null, offset) : null);
       return;
     }
     const due = dueReasons(flow, run, at, timeZone, context);
     if (due.deadline) {
-      await store.setDue(chatId, null);
+      if (!await lease.held()) return;
+      await setDue(null);
       const endAt = flow.schedule ? deadlineAt(run, timeZone, flow.schedule) ?? wake.at : wake.at;
       await input.onDeadline?.({ record, flow, run, at: endAt, timeZone });
       const deadlineState = flow.schedule?.deadlineState;
@@ -1275,7 +1196,8 @@ function createFlowTimers(input) {
       return;
     }
     if (due.giveUp) {
-      await store.setDue(chatId, null);
+      if (!await lease.held()) return;
+      await setDue(null);
       await input.onGiveUp?.({ record, flow, run, at });
       fired(chatId, { kind: "give_up", stateId: run.state });
       return;
@@ -1292,8 +1214,9 @@ function createFlowTimers(input) {
     const reasons = [...moved ? [{ kind: "transition", stateId: next.state }] : [], ...due.reasons];
     const keep = async (wakeAt, applyNow) => {
       const deferred = wakeAt && dueInput(wakeAt, run.answerId ?? null, offset);
+      if (moved && !await lease.held()) return;
       if (moved) await keepForNextTurn(chatId, run, transitions[0], deferred, applyNow ? { record, flow, run: next, transitions, at } : null);
-      else await store.setDue(chatId, deferred);
+      else await setDue(deferred);
     };
     const defer = (retryAt) => keep(deferredWake(flow, next, at, timeZone, context, { at: retryAt, exitId: moved && retryAt !== null ? due.exitId : FLOW_FIRST_EXIT }), retryAt === null);
     if (reasons.length === 0) {
@@ -1330,6 +1253,7 @@ function createFlowTimers(input) {
     const notice = undelivered ? { ...reasonsNotice, data: { ...reasonsNotice.data, undelivered } } : reasonsNotice;
     const reply = moved ? exactFirstText(flow, next.state) : null;
     const delivery = input.delivery?.();
+    if (!await lease.held()) return;
     const result = await chatPort.deliverNotices({
       ownerId,
       chatId,
@@ -1357,27 +1281,23 @@ function createFlowTimers(input) {
     const { nudgeStep, nudgeStepOwn } = notice.data;
     const answered = nudgeStep === void 0 ? noteAgentAnswer(next, at) : withNudgeStep(noteAgentAnswer(next, at), nudgeStep, nudgeStepOwn === true);
     const following = nextWake(flow, answered, at, timeZone, { pausedUntil: context.pausedUntil ?? null });
-    await store.setDue(chatId, following ? dueInput(following, result.messageId ?? null, offset) : null, { unlessDelivery: true });
+    await setDue(following ? dueInput(following, result.messageId ?? null, offset) : null, { unlessDelivery: true });
     fired(chatId, { kind: reasons[0].kind, stateId: next.state, ...moved && { exitId: due.exitId }, reasons });
     if (!delivery) {
       await firstMessages?.record({ ownerId, at, timeZone });
       return;
     }
-    const outcome = await delivery.afterFirstTurn({ ownerId, chatId, answer: result.answer, reasons, at, timeZone });
-    if (outcome === "failed" || outcome === "window_closed") await recountAfterFailure(ownerId, chatId, serverAt);
+    await delivery.afterFirstTurn({ ownerId, chatId, answer: result.answer, reasons, at, timeZone, endedAt: record.endedAt });
   }
   const renew = (chatId) => store.renewLease({ chatId, owner, now: input.now().toISOString(), leaseMs });
   async function fireLeased(record, serverAt) {
     try {
       if (!await renew(record.chatId)) return;
-      const heartbeat = setInterval(() => {
-        renew(record.chatId).catch((error) => logError(`[\u0441\u0446\u0435\u043D\u0430\u0440\u0438\u0439] \u0447\u0430\u0442=${record.chatId} \u0430\u0440\u0435\u043D\u0434\u0430 \u043D\u0435 \u043F\u0440\u043E\u0434\u043B\u0435\u043D\u0430: ${errorText4(error)}`));
-      }, leaseMs / 3);
-      heartbeat.unref?.();
+      const lease = holdLease({ store, chatId: record.chatId, owner, leaseMs, now: input.now, logError });
       try {
-        await fire(record, serverAt);
+        await fire(record, serverAt, lease);
       } finally {
-        clearInterval(heartbeat);
+        await lease.stop();
       }
     } catch (error) {
       logError(`[\u0441\u0446\u0435\u043D\u0430\u0440\u0438\u0439] \u0447\u0430\u0442=${record.chatId} \u0442\u0430\u0439\u043C\u0435\u0440 \u043D\u0435 \u0441\u0440\u0430\u0431\u043E\u0442\u0430\u043B: ${errorText4(error)}`);
@@ -1433,12 +1353,12 @@ function createChatMigrator(deps) {
   async function newVersion(flowId, versionId, raw) {
     if (raw !== void 0) {
       const loaded = { flowId, versionId, flow: raw };
-      const flow = deps.checkedFlow(loaded);
-      if (!flow) throw new Error(`\u0421\u0446\u0435\u043D\u0430\u0440\u0438\u0439 ${flowId}@${versionId} \u043D\u0435 \u0440\u0430\u0437\u043E\u0431\u0440\u0430\u043D \u0438\u043B\u0438 \u0441 \u043E\u0448\u0438\u0431\u043A\u0430\u043C\u0438: \u0447\u0430\u0442\u044B \u043D\u0435 \u043F\u0435\u0440\u0435\u0432\u0435\u0434\u0435\u043D\u044B.`);
+      const flow2 = deps.checkedFlow(loaded);
+      if (!flow2) throw new Error(`\u0421\u0446\u0435\u043D\u0430\u0440\u0438\u0439 ${flowId}@${versionId} \u043D\u0435 \u0440\u0430\u0437\u043E\u0431\u0440\u0430\u043D \u0438\u043B\u0438 \u0441 \u043E\u0448\u0438\u0431\u043A\u0430\u043C\u0438: \u0447\u0430\u0442\u044B \u043D\u0435 \u043F\u0435\u0440\u0435\u0432\u0435\u0434\u0435\u043D\u044B.`);
       return {
-        flow,
+        flow: flow2,
         save: async () => {
-          if (await deps.saveVersion(loaded, flow) === "conflict") {
+          if (await deps.saveVersion(loaded, flow2) === "conflict") {
             throw new Error(`\u041F\u043E\u0434 \u043D\u043E\u043C\u0435\u0440\u043E\u043C ${versionId} \u0443\u0436\u0435 \u0441\u043E\u0445\u0440\u0430\u043D\u0451\u043D \u0434\u0440\u0443\u0433\u043E\u0439 \u0441\u0446\u0435\u043D\u0430\u0440\u0438\u0439 \xAB${flowId}\xBB: \u0432\u043E\u0437\u044C\u043C\u0438\u0442\u0435 \u043D\u043E\u0432\u044B\u0439 \u043D\u043E\u043C\u0435\u0440 \u0432\u0435\u0440\u0441\u0438\u0438.`);
           }
         }
@@ -1446,7 +1366,9 @@ function createChatMigrator(deps) {
     }
     const found = await store.getVersion(flowId, versionId);
     if (!found) throw new Error(`\u0412\u0435\u0440\u0441\u0438\u0438 ${versionId} \u0441\u0446\u0435\u043D\u0430\u0440\u0438\u044F \xAB${flowId}\xBB \u043D\u0435\u0442 \u0432 \u0445\u0440\u0430\u043D\u0438\u043B\u0438\u0449\u0435: \u043F\u0435\u0440\u0435\u0434\u0430\u0439\u0442\u0435 \u0435\u0451 \u0441\u0446\u0435\u043D\u0430\u0440\u0438\u0439 \u0432 \u043F\u043E\u043B\u0435 flow.`);
-    return { flow: found.flow };
+    const flow = deps.checkedFlow({ flowId, versionId, flow: found.flow });
+    if (!flow) throw new Error(`\u0421\u043E\u0445\u0440\u0430\u043D\u0451\u043D\u043D\u0430\u044F \u0432\u0435\u0440\u0441\u0438\u044F ${flowId}@${versionId} \u043D\u0435 \u043F\u0440\u043E\u0448\u043B\u0430 \u043F\u0440\u043E\u0432\u0435\u0440\u043A\u0443: \u0447\u0430\u0442\u044B \u043D\u0435 \u043F\u0435\u0440\u0435\u0432\u0435\u0434\u0435\u043D\u044B.`);
+    return { flow };
   }
   async function selectedChats(flowId, exceptVersionId, selection) {
     const rows = await store.listFlowChats({ flowId, ...exceptVersionId !== void 0 && { exceptVersionId }, ...selection.chatIds && { chatIds: selection.chatIds } });
@@ -1508,7 +1430,7 @@ function createChatMigrator(deps) {
 
 // src/runtime/flow-signals.ts
 import { randomUUID as randomUUID2 } from "crypto";
-import { ChatNotFoundError as ChatNotFoundError3 } from "@ykurilov/agent-chat-core";
+import { ChatNotFoundError as ChatNotFoundError2 } from "@ykurilov/agent-chat-core";
 async function sendFlowSignal(input) {
   const { runtime, port, signal } = input;
   const { ownerId, chatId, name } = signal;
@@ -1524,7 +1446,7 @@ async function sendFlowSignal(input) {
   try {
     ({ values } = await port.getChatState(ownerId, chatId));
   } catch (error) {
-    if (error instanceof ChatNotFoundError3) return;
+    if (error instanceof ChatNotFoundError2) return;
     throw error;
   }
   const transitions = [];
@@ -2019,13 +1941,243 @@ function createFlowPause({
   };
 }
 
+// src/runtime/flow-delivery.ts
+import { randomUUID as randomUUID4 } from "crypto";
+import { answerText, ChatNotFoundError as ChatNotFoundError3, deliverableParts, isHumanMessage } from "@ykurilov/agent-chat-core";
+var RETRY_DELAYS_MS = [6e4, 5 * 6e4, 30 * 6e4];
+var pauseOf = (attempt) => RETRY_DELAYS_MS[Math.min(attempt, RETRY_DELAYS_MS.length) - 1];
+var errorText5 = (error) => error instanceof Error ? error.message : String(error);
+var isoOf2 = (at) => new Date(at).toISOString();
+var hasContent = (answer) => answer.text.trim() !== "" || answer.parts.some((part) => part.type !== "text");
+function createFlowDelivery(input) {
+  const { runtime } = input;
+  const store = runtime.store;
+  const portOf = (chat) => {
+    if (!input.port) throw new Error("\u0414\u043E\u0441\u0442\u0430\u0432\u043A\u0430 \u0441\u0446\u0435\u043D\u0430\u0440\u0438\u044F \u0441\u043E\u0431\u0440\u0430\u043D\u0430 \u0431\u0435\u0437 \u0441\u043B\u0443\u0436\u0431\u044B \u0447\u0430\u0442\u0430");
+    return input.port(chat);
+  };
+  async function recount(chat) {
+    try {
+      await input.recount?.(chat);
+    } catch (error) {
+      runtime.logError(`[\u0441\u0446\u0435\u043D\u0430\u0440\u0438\u0439] \u0447\u0430\u0442=${chat.chatId} \u0441\u0440\u043E\u043A\u0438 \u043F\u043E\u0441\u043B\u0435 \u0434\u043E\u0441\u0442\u0430\u0432\u043A\u0438 \u043D\u0435 \u043F\u0435\u0440\u0435\u0441\u0447\u0438\u0442\u0430\u043D\u044B: ${errorText5(error)}`);
+    }
+  }
+  const writer = `flow-delivery:${randomUUID4()}`;
+  let written = 0;
+  const nextToken = () => `${writer}:d${++written}`;
+  async function markUndelivered(ownerId, chatId, messageId) {
+    try {
+      await (await portOf({ ownerId, chatId })).markUndelivered({ ownerId, chatId, messageId });
+    } catch (error) {
+      if (error instanceof ChatNotFoundError3) return;
+      runtime.logError(`[\u0441\u0446\u0435\u043D\u0430\u0440\u0438\u0439] \u0447\u0430\u0442=${chatId} \u043F\u043E\u043C\u0435\u0442\u043A\u0430 \xAB\u043D\u0435 \u0434\u043E\u0441\u0442\u0430\u0432\u043B\u0435\u043D\u043E\xBB \u043D\u0435 \u0437\u0430\u043F\u0438\u0441\u0430\u043D\u0430: ${errorText5(error)}`);
+    }
+  }
+  async function blocked(ownerId, chatId) {
+    const pinned = await runtime.chatFlow(ownerId, chatId);
+    if (!pinned || !input.finish) {
+      await store.endChat(chatId, { reason: "blocked", at: isoOf2(runtime.now()) });
+      return;
+    }
+    const { values } = await (await portOf({ ownerId, chatId })).getChatState(ownerId, chatId);
+    const at = runtime.now();
+    await input.finish().end({ ownerId, chatId, pinned, run: await runOutsideTurn(runtime, { ownerId, chatId }, pinned.flow, values, at), reason: "blocked", at });
+  }
+  async function staleness(record, pending) {
+    let messages;
+    try {
+      ({ messages } = await (await portOf(record)).peekHistory(record.ownerId, record.chatId));
+    } catch (error) {
+      if (error instanceof ChatNotFoundError3) return { stale: true };
+      throw error;
+    }
+    const index = messages.findIndex((message) => message.id === pending.messageId);
+    if (index < 0) return { stale: true };
+    const answer = messages[index];
+    const repaired = pending.resumedAt !== void 0;
+    return { stale: repaired && messages.slice(index + 1).some(isHumanMessage), answer };
+  }
+  async function drop(record, pending, answerId, freeAt) {
+    const { ownerId, chatId } = record;
+    if (!await store.swapDelivery(chatId, { expected: pending, next: null, ...freeAt && { freeAt } })) return false;
+    if (answerId) await markUndelivered(ownerId, chatId, answerId);
+    await recount({ ownerId, chatId, ...answerId && { failedAt: runtime.now() } });
+    return true;
+  }
+  async function settle(reservation, message, outcome, job) {
+    const { ownerId, chatId, messageId } = message;
+    const swap = (next, due) => store.swapDelivery(chatId, {
+      expected: reservation,
+      next,
+      ...due !== void 0 && { due: due && { at: due.at, exitId: FLOW_DELIVERY_EXIT, branchHead: job.branchHead } }
+    });
+    switch (outcome.status) {
+      case "delivered":
+        if (!await swap(null)) return;
+        await input.firstMessages?.()?.record({ ownerId, ...job.counted });
+        await recount({ ownerId, chatId });
+        return;
+      case "retry": {
+        if (message.attempt > RETRY_DELAYS_MS.length) return settle(reservation, message, { status: "failed" }, job);
+        const retryAt = isoOf2(runtime.now() + (outcome.afterMs ?? RETRY_DELAYS_MS[message.attempt - 1]));
+        const { resumedAt } = reservation;
+        await swap({ messageId, attempt: message.attempt + 1, retryAt, reasons: reservation.reasons, token: nextToken(), ...resumedAt && { resumedAt } }, { at: retryAt });
+        return;
+      }
+      case "await_repair": {
+        const { resumedAt: _resumedAt, ...rest } = reservation;
+        await swap({ ...rest, token: nextToken(), pausedAt: isoOf2(runtime.now()) }, null);
+        return;
+      }
+      case "failed":
+      case "window_closed":
+        if (!await swap(null)) return;
+        await markUndelivered(ownerId, chatId, messageId);
+        if (outcome.status === "window_closed") await store.setWindowClosed(chatId, true);
+        await recount({ ownerId, chatId, failedAt: runtime.now() });
+        return;
+      case "blocked":
+        if (!await swap(null)) return;
+        await markUndelivered(ownerId, chatId, messageId);
+        await blocked(ownerId, chatId);
+        return;
+    }
+  }
+  async function send(message) {
+    const deliver = input.deliver();
+    if (!deliver) throw new Error("\u0423 \u043F\u0440\u0438\u043B\u043E\u0436\u0435\u043D\u0438\u044F \u043D\u0435\u0442 \u0441\u0432\u043E\u0435\u0439 \u0434\u043E\u0441\u0442\u0430\u0432\u043A\u0438 (attach({ deliver }))");
+    try {
+      return await deliver(message);
+    } catch (error) {
+      runtime.logError(`[\u0441\u0446\u0435\u043D\u0430\u0440\u0438\u0439] \u0447\u0430\u0442=${message.chatId} \u0434\u043E\u0441\u0442\u0430\u0432\u043A\u0430 \u0443\u043F\u0430\u043B\u0430: ${errorText5(error)}`);
+      return { status: "retry" };
+    }
+  }
+  async function lastCheck(chatId, reservation, endedAt, ready) {
+    const record = await store.getChat(chatId);
+    if (!record || !sameDelivery(record.delivery, reservation)) return { replaced: true };
+    if (endedAt !== void 0 && record.endedAt !== endedAt) return { stale: true, answerId: reservation.messageId };
+    return ready(record);
+  }
+  async function dispatch(job) {
+    const { record, expected, attempt } = job;
+    const { ownerId, chatId } = record;
+    const branchHead = record.dueBranchHead;
+    const now = runtime.now();
+    const reservation = {
+      messageId: attempt.messageId,
+      attempt: attempt.attempt,
+      retryAt: isoOf2(now + pauseOf(attempt.attempt)),
+      reasons: attempt.reasons,
+      token: nextToken(),
+      ...expected?.resumedAt && { resumedAt: expected.resumedAt }
+    };
+    const due = (at) => ({ at, exitId: FLOW_DELIVERY_EXIT, branchHead });
+    const claim = { owner: reservation.token, now: isoOf2(now), leaseMs: input.leaseMs, ...job.from && { from: job.from } };
+    const sameEnd = job.endedAt !== void 0 ? { endedAt: job.endedAt } : {};
+    if (!await store.swapDelivery(chatId, { expected, next: reservation, due: due(reservation.retryAt), claim, ...sameEnd })) {
+      const queued = { ...reservation, retryAt: isoOf2(now), token: nextToken() };
+      if (await store.swapDelivery(chatId, { expected, next: queued, due: due(queued.retryAt), ...sameEnd })) return;
+      if (expected === null) {
+        runtime.logError(`[\u0441\u0446\u0435\u043D\u0430\u0440\u0438\u0439] \u0447\u0430\u0442=${chatId} \u043E\u0442\u0432\u0435\u0442 ${attempt.messageId} \u043D\u0435 \u043E\u0442\u043F\u0440\u0430\u0432\u043B\u0435\u043D: \u0436\u0434\u0451\u0442 \u0434\u0440\u0443\u0433\u0430\u044F \u0434\u043E\u0441\u0442\u0430\u0432\u043A\u0430 \u0438\u043B\u0438 \u0440\u0430\u0437\u0433\u043E\u0432\u043E\u0440 \u0437\u0430\u043A\u043E\u043D\u0447\u0435\u043D`);
+        await markUndelivered(ownerId, chatId, attempt.messageId);
+      }
+      return;
+    }
+    const lease = holdLease({ store, chatId, owner: reservation.token, leaseMs: input.leaseMs, now: () => new Date(runtime.now()), logError: runtime.logError });
+    try {
+      let ready;
+      let outcome;
+      try {
+        ready = await lastCheck(chatId, reservation, job.endedAt, job.ready);
+        if ("message" in ready) outcome = await send(ready.message);
+      } finally {
+        await lease.stop();
+      }
+      if ("message" in ready) await settle(reservation, ready.message, outcome, { counted: job.counted, branchHead });
+      else if ("stale" in ready) await drop(record, reservation, ready.answerId);
+    } finally {
+      await store.releaseLease(chatId, reservation.token);
+    }
+  }
+  return {
+    own: () => Boolean(input.deliver()),
+    async afterFirstTurn({ ownerId, chatId, answer, reasons, at, timeZone, endedAt }) {
+      if (!input.deliver()) {
+        await input.firstMessages?.()?.record({ ownerId, at, timeZone });
+        return;
+      }
+      if (!answer || answer.status !== "complete" || !hasContent(answer)) return;
+      const record = await store.getChat(chatId);
+      if (!record) return;
+      if (record.endedAt !== endedAt) {
+        await markUndelivered(ownerId, chatId, answer.messageId);
+        return;
+      }
+      const message = { ownerId, chatId, messageId: answer.messageId, text: answer.text, parts: answer.parts, reasons, attempt: 1 };
+      const attempt = { messageId: message.messageId, attempt: 1, reasons: reasons.map((reason) => JSON.stringify(reason)) };
+      await dispatch({ record, expected: null, attempt, endedAt, ready: async () => ({ message }), counted: { at, timeZone } });
+    },
+    async retry(record, serverAt, from) {
+      const pending = record.delivery;
+      if (!pending) return;
+      const { ownerId, chatId } = record;
+      const timeZone = await input.timeZoneOf?.(ownerId, chatId) ?? record.timeZone;
+      const reasons = pending.reasons.map((reason) => JSON.parse(reason));
+      const ready = async (current) => {
+        const { stale, answer } = await staleness(current, current.delivery);
+        if (stale || !answer) return { stale: true, ...answer && { answerId: answer.id } };
+        const message = { ownerId, chatId, messageId: pending.messageId, text: answerText(answer.parts), parts: deliverableParts(answer.parts), reasons, attempt: pending.attempt };
+        return { message };
+      };
+      const attempt = { messageId: pending.messageId, attempt: pending.attempt, reasons: pending.reasons };
+      await dispatch({ record, expected: pending, attempt, ready, counted: { at: serverAt, timeZone }, from });
+    },
+    async resume({ ownerId, chatId, messageId }) {
+      for (let round = 0; round < 3; round += 1) {
+        const record = await store.getChat(chatId);
+        const pending = record?.delivery;
+        if (!record || record.ownerId !== ownerId || !pending || pending.messageId !== messageId) return "not_found";
+        if (pending.pausedAt === void 0) return "pending";
+        const at = isoOf2(runtime.now());
+        const { stale, answer } = await staleness(record, { ...pending, resumedAt: at });
+        if (stale) {
+          if (await drop(record, pending, answer?.id, at)) return "dropped";
+        } else {
+          const next = { messageId, attempt: pending.attempt, retryAt: at, reasons: pending.reasons, token: nextToken(), resumedAt: at };
+          const due = { at, exitId: FLOW_DELIVERY_EXIT, branchHead: record.dueBranchHead };
+          if (await store.swapDelivery(chatId, { expected: pending, next, due, freeAt: at })) return "resumed";
+        }
+        if (sameDelivery((await store.getChat(chatId))?.delivery ?? null, pending)) return "busy";
+      }
+      return "busy";
+    },
+    async report({ chatId, messageId, outcome }) {
+      if (outcome.status === "await_repair") {
+        throw new TypeError("reportDelivery: \u0438\u0441\u0445\u043E\u0434 await_repair \u2014 \u0442\u043E\u043B\u044C\u043A\u043E \u0434\u043B\u044F \u0441\u0432\u043E\u0435\u0439 \u0434\u043E\u0441\u0442\u0430\u0432\u043A\u0438 attach({ deliver }); \u043A\u0430\u043D\u0430\u043B\u044B SDK \u043F\u043E\u0432\u0442\u043E\u0440\u044F\u044E\u0442 \u0441\u0430\u043C\u0438");
+      }
+      const record = await store.getChat(chatId);
+      if (!record) return;
+      const { ownerId } = record;
+      if (outcome.status === "delivered" || outcome.status === "retry") return;
+      await markUndelivered(ownerId, chatId, messageId);
+      if (outcome.status === "window_closed") await store.setWindowClosed(chatId, true);
+      if (outcome.status === "blocked") {
+        await store.setDelivery(chatId, null);
+        await blocked(ownerId, chatId);
+      } else await recount({ ownerId, chatId, failedAt: runtime.now() });
+    }
+  };
+}
+
 // src/runtime/agent-flow.ts
 var JUDGE_HISTORY = 6;
 var DELIVERY_RETRY_MS = [50, 250, 1e3, 3e3];
 var KNOWN_FLOWS_LIMIT = 1e4;
 var KNOWN_PORTS_LIMIT = 1e4;
 var SERVER_UNKNOWN_CODES = /* @__PURE__ */ new Set(["unknown_event"]);
-var errorText5 = (error) => error instanceof Error ? error.message : String(error);
+var errorText6 = (error) => error instanceof Error ? error.message : String(error);
 var pause = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 function stableJson(value) {
   if (Array.isArray(value)) return `[${value.map(stableJson).join(",")}]`;
@@ -2050,6 +2202,9 @@ function turnWindow(messages, run, answer) {
 }
 function buildAgentFlow(options, modules = {}) {
   const { store } = options;
+  if (store?.guarded !== true) {
+    throw new TypeError("createAgentFlow: \u0445\u0440\u0430\u043D\u0438\u043B\u0438\u0449\u0435 \u0441\u0446\u0435\u043D\u0430\u0440\u0438\u0435\u0432 \u0431\u0435\u0437 guarded: true \u2014 \u0441 0.81 \u0441\u0432\u043E\u0451 FlowStore \u0434\u043E\u043B\u0436\u043D\u043E \u0432\u044B\u043F\u043E\u043B\u043D\u044F\u0442\u044C \u0443\u0441\u043B\u043E\u0432\u0438\u044F setDue/swapDelivery/leaseDue/endChat (\u0441\u043C. \u043E\u0431\u043D\u043E\u0432\u043B\u0435\u043D\u0438\u0435 0.81)");
+  }
   const clock = options.now ?? (() => /* @__PURE__ */ new Date());
   const now = () => clock().getTime();
   const iso = () => clock().toISOString();
@@ -2101,7 +2256,7 @@ function buildAgentFlow(options, modules = {}) {
       try {
         return make();
       } catch (error) {
-        logError(`[\u0441\u0446\u0435\u043D\u0430\u0440\u0438\u0439] ${name} \u043D\u0435\u0434\u043E\u0441\u0442\u0443\u043F\u0435\u043D: ${errorText5(error)}`);
+        logError(`[\u0441\u0446\u0435\u043D\u0430\u0440\u0438\u0439] ${name} \u043D\u0435\u0434\u043E\u0441\u0442\u0443\u043F\u0435\u043D: ${errorText6(error)}`);
         return null;
       }
     });
@@ -2166,7 +2321,7 @@ function buildAgentFlow(options, modules = {}) {
   );
   const background = /* @__PURE__ */ new Set();
   function track(work) {
-    const tracked = work.catch((error) => logError(`[\u0441\u0446\u0435\u043D\u0430\u0440\u0438\u0439] \u0444\u043E\u043D\u043E\u0432\u0430\u044F \u0440\u0430\u0431\u043E\u0442\u0430 \u0443\u043F\u0430\u043B\u0430: ${errorText5(error)}`)).finally(() => background.delete(tracked));
+    const tracked = work.catch((error) => logError(`[\u0441\u0446\u0435\u043D\u0430\u0440\u0438\u0439] \u0444\u043E\u043D\u043E\u0432\u0430\u044F \u0440\u0430\u0431\u043E\u0442\u0430 \u0443\u043F\u0430\u043B\u0430: ${errorText6(error)}`)).finally(() => background.delete(tracked));
     background.add(tracked);
   }
   const known = /* @__PURE__ */ new Map();
@@ -2183,8 +2338,10 @@ function buildAgentFlow(options, modules = {}) {
     let found = versions.get(key);
     if (!found) {
       found = store.getVersion(flowId, versionId).then((saved) => {
-        if (saved) confirmations.validate(flowId, saved.flow);
-        return saved?.flow ?? null;
+        if (!saved) return null;
+        const problem = confirmationProblem(flowId, versionId, saved.flow);
+        if (problem) logError(problem);
+        return problem ? null : saved.flow;
       });
       versions.set(key, found);
       void found.then((flow) => flow ?? versions.delete(key), () => versions.delete(key));
@@ -2197,14 +2354,21 @@ function buildAgentFlow(options, modules = {}) {
     const catalog = { tools: parsed.flow.tools, events: [], widgets: [] };
     const errors = checkFlow(parsed.flow, catalog).filter((issue) => issue.level === "error" && !SERVER_UNKNOWN_CODES.has(issue.code));
     if (errors.length > 0) return { problem: `[\u0441\u0446\u0435\u043D\u0430\u0440\u0438\u0439] ${flowId}@${versionId} \u0441 \u043E\u0448\u0438\u0431\u043A\u0430\u043C\u0438, \u0447\u0430\u0442 \u0438\u0434\u0451\u0442 \u0431\u0435\u0437 \u0441\u0446\u0435\u043D\u0430\u0440\u0438\u044F: ${errors.map((issue) => issue.message).join("; ")}` };
-    return { flow: parsed.flow };
+    const problem = confirmationProblem(flowId, versionId, parsed.flow);
+    return problem ? { problem } : { flow: parsed.flow };
+  }
+  function confirmationProblem(flowId, versionId, flow) {
+    try {
+      confirmations.validate(flowId, flow);
+      return null;
+    } catch (error) {
+      if (!(error instanceof TypeError)) throw error;
+      return `[\u0441\u0446\u0435\u043D\u0430\u0440\u0438\u0439] ${flowId}@${versionId} \u043D\u0435 \u0441\u0445\u043E\u0434\u0438\u0442\u0441\u044F \u0441 \u043F\u043E\u0434\u0442\u0432\u0435\u0440\u0436\u0434\u0435\u043D\u0438\u044F\u043C\u0438 \u043F\u0440\u0438\u043B\u043E\u0436\u0435\u043D\u0438\u044F, \u0447\u0430\u0442 \u0438\u0434\u0451\u0442 \u0431\u0435\u0437 \u0441\u0446\u0435\u043D\u0430\u0440\u0438\u044F: ${error.message}`;
+    }
   }
   function checkedFlow(flowId, versionId, value) {
     const checked = flowOrProblem(flowId, versionId, value);
-    if ("flow" in checked) {
-      confirmations.validate(flowId, checked.flow);
-      return checked.flow;
-    }
+    if ("flow" in checked) return checked.flow;
     logError(checked.problem);
     return null;
   }
@@ -2227,7 +2391,9 @@ function buildAgentFlow(options, modules = {}) {
     if (loaded.stateId !== void 0 && !stateById(flow, loaded.stateId)) {
       return void fail(`[\u0441\u0446\u0435\u043D\u0430\u0440\u0438\u0439] \u0447\u0430\u0442=${chatId}: \u0441\u043E\u0441\u0442\u043E\u044F\u043D\u0438\u044F \xAB${loaded.stateId}\xBB \u043D\u0435\u0442 \u0432 ${loaded.flowId}@${loaded.versionId}, \u0447\u0430\u0442 \u0438\u0434\u0451\u0442 \u0431\u0435\u0437 \u0441\u0446\u0435\u043D\u0430\u0440\u0438\u044F`), null;
     }
-    await saveChecked(loaded, flow);
+    if (await saveChecked(loaded, flow) === "conflict" && !await versionFlow(loaded.flowId, loaded.versionId)) {
+      return void fail(`[\u0441\u0446\u0435\u043D\u0430\u0440\u0438\u0439] \u0447\u0430\u0442=${chatId}: \u0441\u043E\u0445\u0440\u0430\u043D\u0451\u043D\u043D\u0430\u044F \u0432\u0435\u0440\u0441\u0438\u044F ${loaded.flowId}@${loaded.versionId} \u043D\u0435 \u043F\u0440\u043E\u0448\u043B\u0430 \u043F\u0440\u043E\u0432\u0435\u0440\u043A\u0443, \u0447\u0430\u0442 \u0438\u0434\u0451\u0442 \u0431\u0435\u0437 \u0441\u0446\u0435\u043D\u0430\u0440\u0438\u044F`), null;
+    }
     const at = now();
     const startedAt = loaded.startedAt ?? new Date(at);
     const { lastHumanAt, lastAgentAt, nudgeStep, today } = loaded;
@@ -2345,7 +2511,7 @@ function buildAgentFlow(options, modules = {}) {
         return Object.fromEntries(entries.map((entry) => [entry.fieldId, entry.value]));
       } catch (error) {
         if (!app) throw error;
-        logError(`[\u0441\u0446\u0435\u043D\u0430\u0440\u0438\u0439] \u043A\u0430\u0440\u0442\u043E\u0447\u043A\u0430 \u043A\u043B\u0438\u0435\u043D\u0442\u0430 \u043D\u0435 \u043F\u0440\u043E\u0447\u0438\u0442\u0430\u043D\u0430: ${errorText5(error)}`);
+        logError(`[\u0441\u0446\u0435\u043D\u0430\u0440\u0438\u0439] \u043A\u0430\u0440\u0442\u043E\u0447\u043A\u0430 \u043A\u043B\u0438\u0435\u043D\u0442\u0430 \u043D\u0435 \u043F\u0440\u043E\u0447\u0438\u0442\u0430\u043D\u0430: ${errorText6(error)}`);
         return {};
       }
     },
@@ -2354,7 +2520,7 @@ function buildAgentFlow(options, modules = {}) {
       try {
         await store.updateChat(chatId, { stateId: run.state }, iso());
       } catch (error) {
-        logError(`[\u0441\u0446\u0435\u043D\u0430\u0440\u0438\u0439] \u0447\u0430\u0442=${chatId} \u0441\u043E\u0441\u0442\u043E\u044F\u043D\u0438\u0435 \u043D\u0435 \u0437\u0430\u043F\u0438\u0441\u0430\u043D\u043E \u0432 \u0445\u0440\u0430\u043D\u0438\u043B\u0438\u0449\u0435: ${errorText5(error)}`);
+        logError(`[\u0441\u0446\u0435\u043D\u0430\u0440\u0438\u0439] \u0447\u0430\u0442=${chatId} \u0441\u043E\u0441\u0442\u043E\u044F\u043D\u0438\u0435 \u043D\u0435 \u0437\u0430\u043F\u0438\u0441\u0430\u043D\u043E \u0432 \u0445\u0440\u0430\u043D\u0438\u043B\u0438\u0449\u0435: ${errorText6(error)}`);
       }
       const { schedule } = pinned.flow;
       const timeZone = schedule ? await timeZones.of(ownerId, chatId) : null;
@@ -2372,11 +2538,12 @@ function buildAgentFlow(options, modules = {}) {
     () => createFlowDelivery({
       runtime,
       deliver: () => attachment?.deliver,
+      leaseMs: options.timers?.leaseMs ?? DEFAULT_TIMER_LEASE_MS,
       port: portOf,
       finish,
       firstMessages,
       timeZoneOf: (ownerId, chatId) => timeZones.of(ownerId, chatId),
-      onUndelivered: rescheduleUndelivered
+      recount: recountFromState
     })
   );
   async function history(ownerId, chatId, turn) {
@@ -2387,13 +2554,13 @@ function buildAgentFlow(options, modules = {}) {
     try {
       await optionalTimers()?.reschedule({ ownerId, chatId, run, branchHead, ...failedAt !== void 0 && { failedAt } });
     } catch (error) {
-      logError(`[\u0441\u0446\u0435\u043D\u0430\u0440\u0438\u0439] \u0447\u0430\u0442=${chatId} \u0442\u0430\u0439\u043C\u0435\u0440 \u043D\u0435 \u043F\u0435\u0440\u0435\u0441\u0447\u0438\u0442\u0430\u043D: ${errorText5(error)}`);
+      logError(`[\u0441\u0446\u0435\u043D\u0430\u0440\u0438\u0439] \u0447\u0430\u0442=${chatId} \u0442\u0430\u0439\u043C\u0435\u0440 \u043D\u0435 \u043F\u0435\u0440\u0435\u0441\u0447\u0438\u0442\u0430\u043D: ${errorText6(error)}`);
     }
   }
-  async function rescheduleUndelivered({ ownerId, chatId, at }) {
+  async function recountFromState({ ownerId, chatId, failedAt }) {
     const { values } = await (await portOf({ ownerId, chatId })).getChatState(ownerId, chatId);
     const run = storedRun(values[FLOW_STATE_KEY]);
-    if (run) await reschedule(ownerId, chatId, run, run.answerId ?? null, at);
+    if (run) await reschedule(ownerId, chatId, run, run.answerId ?? null, failedAt);
   }
   async function chatData(chat) {
     if (!port && !attachment) return {};
@@ -2411,7 +2578,7 @@ function buildAgentFlow(options, modules = {}) {
       if (!run) return;
       await reschedule(record.ownerId, record.chatId, migrateRun(run, flow, map, chatTime(run, now())), run.answerId ?? null);
     } catch (error) {
-      logError(`[\u0441\u0446\u0435\u043D\u0430\u0440\u0438\u0439] \u0447\u0430\u0442=${record.chatId} \u0442\u0430\u0439\u043C\u0435\u0440 \u043D\u0435 \u043F\u0435\u0440\u0435\u0441\u0447\u0438\u0442\u0430\u043D: ${errorText5(error)}`);
+      logError(`[\u0441\u0446\u0435\u043D\u0430\u0440\u0438\u0439] \u0447\u0430\u0442=${record.chatId} \u0442\u0430\u0439\u043C\u0435\u0440 \u043D\u0435 \u043F\u0435\u0440\u0435\u0441\u0447\u0438\u0442\u0430\u043D: ${errorText6(error)}`);
     }
   }
   async function deliverFirstText(ownerId, chatId, messageId, condition, text, guarded2 = false) {
@@ -2567,10 +2734,18 @@ function buildAgentFlow(options, modules = {}) {
     const { values } = await (await portOf({ ownerId, chatId })).getChatState(ownerId, chatId);
     const run = await runOutsideTurn(runtime, { ownerId, chatId }, pinned.flow, values, now(), record);
     await store.setDelivery(chatId, null);
-    const result = await finish().end({ ownerId, chatId, pinned, run, reason, ...outcome !== void 0 && { outcome }, at: chatTime(run, now()) });
-    if (result.ended) remember(chatId, { ...pinned, ended: true });
+    const at = chatTime(run, now());
+    const result = await finish().end({ ownerId, chatId, pinned, run, reason, ...outcome !== void 0 && { outcome }, at });
+    if (result.ended && await dropDeliveryAfterEnd(chatId, new Date(at).toISOString())) remember(chatId, { ...pinned, ended: true });
     return result;
   }
+  async function dropDeliveryAfterEnd(chatId, endedAt) {
+    const sameEnd = (record) => record !== null && record.endedAt !== null && Date.parse(record.endedAt) === Date.parse(endedAt);
+    for (let record = await store.getChat(chatId); sameEnd(record); record = await store.getChat(chatId)) {
+      if (await store.swapDelivery(chatId, { expected: record.delivery, next: null, due: null, endedAt })) return true;
+    }
+    return false;
+  }
   const CLOSED_FOR_GOOD = /* @__PURE__ */ new Set(["final", "deadline", "blocked"]);
   async function reopen({ ownerId, chatId, reason, endedAfter }) {
     const pinned = await chatFlow(ownerId, chatId);
@@ -2612,7 +2787,7 @@ function buildAgentFlow(options, modules = {}) {
         at: new Date(at)
       };
       track(
-        Promise.resolve().then(() => onReopen(event)).catch((error) => logError(`[\u0441\u0446\u0435\u043D\u0430\u0440\u0438\u0439] \u0447\u0430\u0442=${chatId} onReopen \u0443\u043F\u0430\u043B: ${errorText5(error)}`))
+        Promise.resolve().then(() => onReopen(event)).catch((error) => logError(`[\u0441\u0446\u0435\u043D\u0430\u0440\u0438\u0439] \u0447\u0430\u0442=${chatId} onReopen \u0443\u043F\u0430\u043B: ${errorText6(error)}`))
       );
     }
     return { reopened: true };
@@ -2632,7 +2807,7 @@ function buildAgentFlow(options, modules = {}) {
       await store.updateChat(chatId, { placement: null }, iso());
     } catch (error) {
       placedNow.add(chatId);
-      logError(`[\u0441\u0446\u0435\u043D\u0430\u0440\u0438\u0439] \u0447\u0430\u0442=${chatId} \u0437\u0430\u043F\u0438\u0441\u044C \u043F\u0435\u0440\u0435\u043D\u043E\u0441\u0430 \u043D\u0435 \u0441\u043D\u044F\u0442\u0430: ${errorText5(error)}`);
+      logError(`[\u0441\u0446\u0435\u043D\u0430\u0440\u0438\u0439] \u0447\u0430\u0442=${chatId} \u0437\u0430\u043F\u0438\u0441\u044C \u043F\u0435\u0440\u0435\u043D\u043E\u0441\u0430 \u043D\u0435 \u0441\u043D\u044F\u0442\u0430: ${errorText6(error)}`);
     }
   }
   async function readRun(ownerId, chatId) {
@@ -2742,7 +2917,7 @@ ${rules}`;
                 try {
                   await store.updateChat(input.chatId, { stateId: run.state }, iso());
                 } catch (error) {
-                  logError(`[\u0441\u0446\u0435\u043D\u0430\u0440\u0438\u0439] \u0447\u0430\u0442=${input.chatId} \u0441\u043E\u0441\u0442\u043E\u044F\u043D\u0438\u0435 \u043D\u0435 \u0437\u0430\u043F\u0438\u0441\u0430\u043D\u043E \u0432 \u0445\u0440\u0430\u043D\u0438\u043B\u0438\u0449\u0435: ${errorText5(error)}`);
+                  logError(`[\u0441\u0446\u0435\u043D\u0430\u0440\u0438\u0439] \u0447\u0430\u0442=${input.chatId} \u0441\u043E\u0441\u0442\u043E\u044F\u043D\u0438\u0435 \u043D\u0435 \u0437\u0430\u043F\u0438\u0441\u0430\u043D\u043E \u0432 \u0445\u0440\u0430\u043D\u0438\u043B\u0438\u0449\u0435: ${errorText6(error)}`);
                 }
                 await reschedule(input.ownerId, input.chatId, run, input.reason === "flowCommit" ? run.answerId ?? null : input.atMessageId);
               })();
@@ -2755,6 +2930,9 @@ ${rules}`;
       };
     },
     attach(target) {
+      if ("portFor" in target && target.deliver && typeof store.swapDelivery !== "function") {
+        throw new TypeError("flow.attach({ deliver }): \u0445\u0440\u0430\u043D\u0438\u043B\u0438\u0449\u0443 \u0441\u0446\u0435\u043D\u0430\u0440\u0438\u0435\u0432 \u043D\u0443\u0436\u0435\u043D swapDelivery (\u0441 0.81) \u2014 \u0431\u0435\u0437 \u043D\u0435\u0433\u043E \u0434\u043E\u0441\u0442\u0430\u0432\u043A\u0430 \u043D\u0435 \u0437\u0430\u0449\u0438\u0449\u0435\u043D\u0430 \u043E\u0442 \u0432\u0442\u043E\u0440\u043E\u0439 \u043A\u043E\u043F\u0438\u0438");
+      }
       if ("portFor" in target) {
         attachment = target;
         port = void 0;
@@ -2768,7 +2946,7 @@ ${rules}`;
       if (signal.wakeAgent) return sendFlowSignal({ runtime, port: await portOf(signal), signal });
       await store.addPending(signal.chatId, {
         kind: "event",
-        key: `signal:${randomUUID4()}`,
+        key: `signal:${randomUUID5()}`,
         name: signal.name,
         ...signal.data !== void 0 && { data: signal.data },
         at: iso()
@@ -2782,6 +2960,7 @@ ${rules}`;
     resume: (input) => pauses().resume(input),
     noteStaffReply: (input) => pauses().noteStaffReply(input),
     reportDelivery: (input) => delivery().report(input),
+    resumeDelivery: (input) => delivery().resume(input),
     readRun,
     revokeConfirmation,
     previewMigration: (input) => previewConfirmedMigration(input, { store, confirmations, portFor: portOf }),
@@ -2834,7 +3013,7 @@ function memoryFlowStore() {
   const versionKey = (flowId, versionId) => JSON.stringify([flowId, versionId]);
   const dayKey = (ownerId, day) => JSON.stringify([ownerId, day]);
   const isFree = (row, now) => row.leaseUntil === null || row.leaseUntil < now;
-  const isRunning = (row, now) => row.endedAt === null && (row.pausedUntil === null || row.pausedUntil <= now);
+  const isRunning = (row, now) => (row.endedAt === null || row.dueExitId === FLOW_DELIVERY_EXIT) && (row.pausedUntil === null || row.pausedUntil <= now);
   const withChat = (chatId, change) => {
     const row = chats.get(chatId);
     if (!row) return null;
@@ -2842,6 +3021,7 @@ function memoryFlowStore() {
     return toRecord(row);
   };
   return {
+    guarded: true,
     async pinChat(input) {
       const existing = chats.get(input.chatId);
       if (existing) return toRecord(existing);
@@ -2903,6 +3083,7 @@ function memoryFlowStore() {
     async setDue(chatId, due, options) {
       const row = chats.get(chatId);
       if (!row || options?.unlessDelivery && row.delivery) return;
+      if (options?.leaseOwner !== void 0 && row.leaseOwner !== options.leaseOwner) return;
       row.dueAt = due ? normalizeTime(due.at) : null;
       row.dueExitId = due?.exitId ?? null;
       row.dueBranchHead = due?.branchHead ?? null;
@@ -2986,7 +3167,8 @@ function memoryFlowStore() {
     async endChat(chatId, { reason, at }) {
       return withChat(chatId, (row) => {
         if (row.endedAt !== null) return;
-        Object.assign(row, { endedAt: normalizeTime(at), endReason: reason, dueAt: null, dueExitId: null, dueBranchHead: null, leaseUntil: null, leaseOwner: null });
+        Object.assign(row, { endedAt: normalizeTime(at), endReason: reason });
+        if (row.delivery === null) Object.assign(row, { dueAt: null, dueExitId: null, dueBranchHead: null, leaseUntil: null, leaseOwner: null });
       });
     },
     async reopenChat(chatId, { endedAt, at }) {
@@ -3005,7 +3187,18 @@ function memoryFlowStore() {
       withChat(chatId, (row) => row.dayClosedOn = day);
     },
     async setDelivery(chatId, delivery) {
-      withChat(chatId, (row) => row.delivery = delivery === null ? null : copy({ ...delivery, retryAt: normalizeTime(delivery.retryAt) }));
+      withChat(chatId, (row) => row.delivery = delivery === null ? null : copy(normalizedDelivery(delivery)));
+    },
+    async swapDelivery(chatId, { expected, next, due, claim, freeAt, endedAt }) {
+      const row = chats.get(chatId);
+      if (!row || !sameDelivery(row.delivery, expected)) return false;
+      if (endedAt !== void 0 && row.endedAt !== (endedAt && normalizeTime(endedAt))) return false;
+      if (claim && !(isFree(row, normalizeTime(claim.now)) || row.leaseOwner === claim.owner || claim.from !== void 0 && row.leaseOwner === claim.from)) return false;
+      if (freeAt !== void 0 && !isFree(row, normalizeTime(freeAt))) return false;
+      row.delivery = next === null ? null : copy(normalizedDelivery(next));
+      if (due !== void 0) Object.assign(row, { dueAt: due ? normalizeTime(due.at) : null, dueExitId: due?.exitId ?? null, dueBranchHead: due?.branchHead ?? null });
+      if (claim) Object.assign(row, { leaseOwner: claim.owner, leaseUntil: new Date(Date.parse(normalizeTime(claim.now)) + claim.leaseMs).toISOString() });
+      return true;
     },
     async readTimeZone(ownerId) {
       return timeZones.get(ownerId) ?? null;