@ykurilov/agent-chat-flows 0.76.0 → 0.78.0

package/dist/index.js

@@ -7,7 +7,7 @@ import {
   sideTaskFieldKnown,
   sideTaskRecord,
   sideTaskStanding
-} from "./chunk-PLY57QT5.js";
+} from "./chunk-CW6VSYZC.js";
 import {
   FACT_PREFIX,
   FIRST_MESSAGE_RETRY_MS,
@@ -44,6 +44,7 @@ import {
   isFactEntry,
   judgeExits,
   pageTimeZone,
+  pendingEvent,
   personTimeZone,
   reportTransition,
   runOutsideTurn,
@@ -56,7 +57,7 @@ import {
   transitionReport,
   withPending,
   withReopen
-} from "./chunk-DQQ2GCQ2.js";
+} from "./chunk-CZ3EDVYW.js";
 import {
   AGENT_FLOW_FORMAT,
   AGENT_FLOW_FORMAT_VERSION,
@@ -140,7 +141,7 @@ import {
   withDayAnchor,
   withNudgeStep,
   withoutUndeliveredTouch
-} from "./chunk-2LAVG3YR.js";
+} from "./chunk-RMWVLMGY.js";
 import {
   appliedInTime,
   byVersionAndState,
@@ -167,10 +168,175 @@ var FLOW_SERVICE_BLOCKS = [
   }
 ];
 
+// src/runtime/confirmations.ts
+import { createHash } from "crypto";
+var confirmationHash = (spec) => createHash("sha256").update(spec.judge).digest("hex");
+function confirmationHolds(record, spec, scope) {
+  return record?.status === "confirmed" && record.key === spec.key && record.revision === spec.revision && record.criterionHash === confirmationHash(spec) && record.scope?.ownerId === scope.ownerId && record.scope.chatId === scope.chatId && record.scope.flowId === scope.flowId && scope.flowId === spec.flowId && record.source?.kind === "judge" && typeof record.source.versionId === "string" && record.source.versionId.length > 0 && typeof record.source.answerId === "string" && record.source.answerId.length > 0 && typeof record.source.humanMessageId === "string" && record.source.humanMessageId.length > 0 && Number.isFinite(record.source.probability) && record.source.probability >= 0 && record.source.probability <= 1;
+}
+function createConfirmations(specs = [], guards = []) {
+  const registered = structuredClone(specs);
+  const registeredGuards = structuredClone(guards);
+  const short = (value) => typeof value === "string" && value.trim().length > 0 && value.length <= 100;
+  const seen = /* @__PURE__ */ new Set();
+  for (const spec of registered) {
+    const id = `${spec.flowId}\0${spec.key}`;
+    if (![spec.flowId, spec.key, spec.revision].every(short) || !spec.judge?.trim() || spec.judge.length > 800 || !Array.isArray(spec.states) || !spec.states.length || !spec.states.every(short) || seen.has(id)) throw new TypeError("confirmations: \u043D\u0443\u0436\u043D\u044B \u0443\u043D\u0438\u043A\u0430\u043B\u044C\u043D\u044B\u0435 flowId/key, revision, states \u0438 judge \u0434\u043E 800 \u0437\u043D\u0430\u043A\u043E\u0432");
+    seen.add(id);
+  }
+  const seenGuards = /* @__PURE__ */ new Set();
+  for (const guard of registeredGuards) {
+    const id = `${guard.flowId}\0${guard.state}\0${guard.exitId}`;
+    if (![guard.flowId, guard.state, guard.exitId].every(short) || guard.judgeWindow !== "current-human-turn" || seenGuards.has(id) || !registered.some((spec) => spec.flowId === guard.flowId && spec.key === guard.requires.key && spec.revision === guard.requires.revision)) throw new TypeError("exitGuards: \u043E\u0434\u0438\u043D guard \u043D\u0430 \u0432\u044B\u0445\u043E\u0434, \u0437\u0430\u0440\u0435\u0433\u0438\u0441\u0442\u0440\u0438\u0440\u043E\u0432\u0430\u043D\u043D\u044B\u0439 requires \u0438 current-human-turn");
+    seenGuards.add(id);
+  }
+  const specFor = (flowId, ref) => registered.find((spec) => spec.flowId === flowId && spec.key === ref.key && spec.revision === ref.revision);
+  const guardFor = (flowId, state, exitId) => registeredGuards.find((guard) => guard.flowId === flowId && guard.state === state && guard.exitId === exitId);
+  return {
+    validate(flowId, flow) {
+      for (const guard of registeredGuards.filter((item) => item.flowId === flowId)) {
+        const state = flow.states.find((item) => item.id === guard.state);
+        const exit = state && activeExits(flow, state).find((item) => item.exit.id === guard.exitId)?.exit;
+        if (exit && exit.when.type !== "judge") throw new TypeError(`exitGuards: ${flowId}/${guard.state}/${guard.exitId} \u0434\u043E\u043B\u0436\u0435\u043D \u0431\u044B\u0442\u044C judge-\u0432\u044B\u0445\u043E\u0434\u043E\u043C`);
+      }
+    },
+    forState: (flowId, state) => registered.filter((spec) => spec.flowId === flowId && spec.states.includes(state)),
+    specFor,
+    guardFor,
+    revision: (flowId) => createHash("sha256").update(JSON.stringify([registered.filter((spec) => spec.flowId === flowId), registeredGuards.filter((guard) => guard.flowId === flowId)])).digest("hex"),
+    allows(scope, run, exitId) {
+      const guard = guardFor(scope.flowId, run.state, exitId);
+      if (!guard) return true;
+      const spec = specFor(scope.flowId, guard.requires);
+      const decision = run.checkedTransition;
+      return confirmationHolds(run.confirmations?.[spec.key], spec, scope) && decision?.transition.exitId === exitId && decision.answerId === run.answerId && decision.requires.key === spec.key && decision.requires.revision === spec.revision && decision.criterionHash === confirmationHash(spec);
+    }
+  };
+}
+
+// src/runtime/confirmation-judge.ts
+import { flowStateCommitter } from "@ykurilov/agent-chat-core";
+var textOf = (message) => message.parts.flatMap((part) => part.type === "text" ? [part.text] : []).join("\n");
+var messagesOf = (messages) => messages.flatMap((message) => {
+  const text = textOf(message).trim();
+  return text && (message.role === "user" || message.role === "assistant") ? [{ role: message.role === "user" ? "human" : "agent", text }] : [];
+});
+async function judgeConfirmations(input) {
+  const { confirmations, pinned, run, result, port } = input;
+  const configurationHash = confirmations.revision(pinned.flowId);
+  if (run.confirmationCheck?.answerId === result.messageId && run.confirmationCheck.configurationHash === configurationHash) return { saved: true };
+  const scope = { ownerId: result.ownerId, chatId: result.chatId, flowId: pinned.flowId };
+  const commit2 = flowStateCommitter(port);
+  if (!commit2) throw new Error("confirmations: \u0441\u043B\u0443\u0436\u0431\u0430 \u0447\u0430\u0442\u0430 \u043D\u0435 \u043F\u0440\u0435\u0434\u043E\u0441\u0442\u0430\u0432\u043B\u044F\u0435\u0442 \u0432\u043D\u0443\u0442\u0440\u0435\u043D\u043D\u044E\u044E flows capability");
+  const all = (await port.peekHistory(scope.ownerId, scope.chatId)).messages;
+  const answerIndex = all.findIndex((message) => message.id === result.messageId);
+  if (answerIndex < 0) return { saved: false };
+  const branch = all.slice(0, answerIndex + 1);
+  const humanIndex = branch.findLastIndex((message) => message.role === "user" && Boolean(textOf(message).trim()));
+  if (humanIndex < 0) return { saved: false };
+  const humanMessageId = branch[humanIndex].id;
+  const records = { ...run.confirmations };
+  const onBranch = (record) => record?.status === "confirmed" && branch.some((message) => message.id === record.source.answerId) && branch.some((message) => message.id === record.source.humanMessageId);
+  const query = async (conditions, messages) => input.judge.checkAll({
+    ...scope,
+    conditions,
+    messages,
+    ...input.goal && { goal: input.goal },
+    ...run.timeOffset !== void 0 && { testChat: true }
+  });
+  for (const spec of confirmations.forState(scope.flowId, run.state)) {
+    const old = records[spec.key];
+    if (confirmationHolds(old, spec, scope) && onBranch(old)) continue;
+    const recordedVersion = old?.status === "confirmed" ? old.source?.versionId : old?.versionId;
+    if (recordedVersion === pinned.versionId && (old.revision !== spec.revision || old.criterionHash !== confirmationHash(spec))) continue;
+    let evidence = input.messages;
+    if (old?.status === "revoked" && old.scope.ownerId === scope.ownerId && old.scope.chatId === scope.chatId && old.scope.flowId === scope.flowId) {
+      const boundary = old.afterMessageId === null ? -1 : branch.findIndex((message) => message.id === old.afterMessageId);
+      if (old.afterMessageId !== null && boundary < 0 || humanIndex <= boundary) continue;
+      evidence = messagesOf(branch.slice(boundary + 1)).slice(-6);
+    }
+    const id = `confirmation:${spec.key}`;
+    const verdict = (await query([{ exitId: id, text: spec.judge }], evidence)).find((item) => item.exitId === id && item.confirmed && item.probability >= input.threshold);
+    if (!verdict) continue;
+    records[spec.key] = {
+      key: spec.key,
+      revision: spec.revision,
+      status: "confirmed",
+      scope,
+      criterionHash: confirmationHash(spec),
+      checkedAt: input.now,
+      source: { kind: "judge", versionId: pinned.versionId, answerId: result.messageId, humanMessageId, probability: verdict.probability }
+    };
+  }
+  const next = { ...run, confirmationCheck: { answerId: result.messageId, configurationHash }, ...Object.keys(records).length && { confirmations: records } };
+  const ordinary = input.conditions.filter((condition) => !confirmations.guardFor(scope.flowId, run.state, condition.exitId));
+  const guarded2 = input.conditions.filter((condition) => {
+    const guard = confirmations.guardFor(scope.flowId, run.state, condition.exitId);
+    if (!guard) return false;
+    const spec = confirmations.specFor(scope.flowId, guard.requires);
+    const receipt = records[spec.key];
+    return confirmationHolds(receipt, spec, scope) && onBranch(receipt);
+  });
+  const verdicts = [
+    ...ordinary.length ? await query(ordinary, input.messages) : [],
+    ...guarded2.length ? await query(guarded2, messagesOf([branch[humanIndex], branch[answerIndex]])) : []
+  ];
+  const met = input.conditions.map(({ exitId }) => verdicts.find((verdict) => verdict.exitId === exitId && verdict.confirmed && verdict.probability >= input.threshold)).find(Boolean);
+  const transition = met ? nextTransition(pinned.flow, next, { type: "verdict", exitId: met.exitId, probability: met.probability, decidedBy: "judge" }, input.now) : null;
+  if (transition) {
+    const guard = confirmations.guardFor(scope.flowId, run.state, transition.exitId);
+    if (guard) next.checkedTransition = { versionId: pinned.versionId, transition, requires: guard.requires, criterionHash: confirmationHash(confirmations.specFor(scope.flowId, guard.requires)), answerId: result.messageId, humanMessageId };
+  }
+  const changed = JSON.stringify(next) !== JSON.stringify(run);
+  if (!changed) return { ...transition && { transition }, saved: true };
+  for (const wait2 of [0, 10, 50, 100, 250, 500, 1e3]) {
+    if (wait2) await new Promise((resolve) => setTimeout(resolve, wait2));
+    const saved = await commit2({ ...scope, revision: confirmations.revision(scope.flowId), expectedAtMessageId: input.atMessageId, idempotencyKey: `judge:${result.messageId}`, flow: next });
+    if (saved.status === "applied" || saved.status === "same") return { ...transition && { transition }, saved: true };
+    if (saved.status !== "busy") return { saved: false };
+  }
+  return { saved: false };
+}
+
+// src/runtime/confirmation-migration.ts
+async function previewConfirmedMigration(input, deps) {
+  const { store, confirmations } = deps;
+  const spec = confirmations.specFor(input.flowId, input.requiresConfirmation);
+  if (!spec) throw new TypeError("previewMigration: requiresConfirmation \u043D\u0435 \u0437\u0430\u0440\u0435\u0433\u0438\u0441\u0442\u0440\u0438\u0440\u043E\u0432\u0430\u043D \u0441\u0435\u0440\u0432\u0435\u0440\u043E\u043C");
+  const eligible = [];
+  const keepOriginal = [];
+  const rows = await store.listFlowChats({ flowId: input.flowId, exceptVersionId: input.toVersionId, ...input.chatIds && { chatIds: input.chatIds } });
+  for (const row of rows) {
+    if (row.endedAt && !input.includeEnded) continue;
+    const port = await deps.portFor(row);
+    const data = await port.getChatData(row.ownerId, row.chatId);
+    const test = testChatOffset(data) !== null;
+    if (test && !input.includeTestChats) continue;
+    if (input.filter && !await input.filter({ chatId: row.chatId, ownerId: row.ownerId, flowId: row.flowId, versionId: row.versionId, stateId: row.stateId, ended: row.endedAt !== null, endReason: row.endReason, test, data })) continue;
+    const snapshot = await port.getChatState(row.ownerId, row.chatId);
+    const run = storedRun(snapshot.values.flow);
+    const receipt = run?.confirmations?.[spec.key];
+    const scope = { ownerId: row.ownerId, chatId: row.chatId, flowId: row.flowId };
+    let reason;
+    if (!receipt) reason = "missing_receipt";
+    else if (receipt.status === "revoked") reason = "revoked_receipt";
+    else if (!confirmationHolds(receipt, spec, scope)) reason = "incompatible_receipt";
+    else if (!await store.getVersion(row.flowId, receipt.source.versionId)) reason = "source_version_missing";
+    else {
+      const branch = (await port.peekHistory(row.ownerId, row.chatId)).messages;
+      if (!branch.some((message) => message.id === receipt.source.answerId) || !branch.some((message) => message.id === receipt.source.humanMessageId)) reason = "source_not_on_branch";
+    }
+    if (reason) keepOriginal.push({ chatId: row.chatId, status: "ambiguous", reason });
+    else eligible.push(row.chatId);
+  }
+  return { eligible, keepOriginal };
+}
+
 // src/runtime/agent-flow.ts
-import { createHash, randomUUID as randomUUID4 } from "crypto";
+import { createHash as createHash2, randomUUID as randomUUID4 } from "crypto";
 import {
-  ChatNotFoundError as ChatNotFoundError4
+  ChatNotFoundError as ChatNotFoundError4,
+  flowStateCommitter as flowStateCommitter2
 } from "@ykurilov/agent-chat-core";
 
 // src/runtime/turn-tool-names.ts
@@ -1606,6 +1772,7 @@ function flowExitTool(input, model) {
       const { flow } = turn.pinned;
       const chosen = judgeExits(flow, turn.run.state)[exit - 1];
       if (!chosen) return `\u041D\u0435\u0442 \u0442\u0430\u043A\u043E\u0433\u043E \u0443\u0441\u043B\u043E\u0432\u0438\u044F: \u043D\u043E\u043C\u0435\u0440 ${exit}. \u041D\u043E\u043C\u0435\u0440\u0430 \u0443\u0441\u043B\u043E\u0432\u0438\u0439 \u2014 \u0432 \u043A\u0430\u0440\u0442\u043E\u0447\u043A\u0435 \u0441\u043E\u0441\u0442\u043E\u044F\u043D\u0438\u044F.`;
+      if (runtime.confirmations?.guardFor(turn.pinned.flowId, turn.run.state, chosen.exitId)) return "\u042D\u0442\u043E\u0442 \u0432\u044B\u0445\u043E\u0434 \u043F\u0440\u043E\u0432\u0435\u0440\u044F\u0435\u0442\u0441\u044F \u0441\u0435\u0440\u0432\u0435\u0440\u043E\u043C \u043F\u043E\u0441\u043B\u0435 \u043F\u043E\u043B\u043D\u043E\u0433\u043E \u043E\u0442\u0432\u0435\u0442\u0430: \u043F\u043E\u0434\u0442\u0432\u0435\u0440\u0436\u0434\u0451\u043D\u043D\u0430\u044F \u0432\u0435\u0445\u0430 \u0438 \u0430\u043A\u0442\u0443\u0430\u043B\u044C\u043D\u043E\u0435 \u0441\u043E\u043E\u0431\u0449\u0435\u043D\u0438\u0435 \u0447\u0435\u043B\u043E\u0432\u0435\u043A\u0430 \u0434\u043E\u043B\u0436\u043D\u044B \u0431\u044B\u0442\u044C \u043F\u0440\u043E\u0432\u0435\u0440\u0435\u043D\u044B \u0432\u043C\u0435\u0441\u0442\u0435. \u041F\u0435\u0440\u0435\u0445\u043E\u0434 \u043F\u043E\u043A\u0430 \u043D\u0435 \u0432\u044B\u043F\u043E\u043B\u043D\u0435\u043D.";
       if (!claimAllowed(turn.run, chosen.exitId)) return "\u042D\u0442\u043E \u0443\u0441\u043B\u043E\u0432\u0438\u0435 \u0443\u0436\u0435 \u043F\u0440\u043E\u0432\u0435\u0440\u044F\u043B\u0438: \u043F\u043E\u0434\u043E\u0436\u0434\u0438 \u043E\u0442\u0432\u0435\u0442\u0430 \u0447\u0435\u043B\u043E\u0432\u0435\u043A\u0430 \u0438 \u043F\u0440\u043E\u0434\u043E\u043B\u0436\u0430\u0439 \u0440\u0430\u0437\u0433\u043E\u0432\u043E\u0440.";
       const state = stateById(flow, turn.run.state);
       let verdict;
@@ -1887,6 +2054,7 @@ function buildAgentFlow(options, modules = {}) {
   const now = () => clock().getTime();
   const iso = () => clock().toISOString();
   const logError = options.logError ?? ((message) => console.error(message));
+  const confirmations = createConfirmations(options.confirmations, options.exitGuards);
   const defaultTimeZone = options.defaultTimeZone === void 0 ? void 0 : ianaTimeZone(options.defaultTimeZone);
   if (defaultTimeZone === null) throw new TypeError(`createAgentFlow: defaultTimeZone \xAB${options.defaultTimeZone}\xBB \u2014 \u043D\u0435 \u043F\u043E\u044F\u0441 IANA`);
   let port;
@@ -2014,7 +2182,10 @@ function buildAgentFlow(options, modules = {}) {
     const key = `${flowId}\0${versionId}`;
     let found = versions.get(key);
     if (!found) {
-      found = store.getVersion(flowId, versionId).then((saved) => saved?.flow ?? null);
+      found = store.getVersion(flowId, versionId).then((saved) => {
+        if (saved) confirmations.validate(flowId, saved.flow);
+        return saved?.flow ?? null;
+      });
       versions.set(key, found);
       void found.then((flow) => flow ?? versions.delete(key), () => versions.delete(key));
     }
@@ -2030,12 +2201,15 @@ function buildAgentFlow(options, modules = {}) {
   }
   function checkedFlow(flowId, versionId, value) {
     const checked = flowOrProblem(flowId, versionId, value);
-    if ("flow" in checked) return checked.flow;
+    if ("flow" in checked) {
+      confirmations.validate(flowId, checked.flow);
+      return checked.flow;
+    }
     logError(checked.problem);
     return null;
   }
   async function saveChecked(loaded, flow) {
-    const saved = await store.saveVersion({ flowId: loaded.flowId, versionId: loaded.versionId, hash: createHash("sha256").update(stableJson(flow)).digest("hex"), flow, at: iso() });
+    const saved = await store.saveVersion({ flowId: loaded.flowId, versionId: loaded.versionId, hash: createHash2("sha256").update(stableJson(flow)).digest("hex"), flow, at: iso() });
     if (saved === "conflict") logError(`[\u0441\u0446\u0435\u043D\u0430\u0440\u0438\u0439] ${loaded.flowId}@${loaded.versionId}: \u043F\u043E\u0434 \u044D\u0442\u0438\u043C \u043D\u043E\u043C\u0435\u0440\u043E\u043C \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, \u0447\u0430\u0442 \u0438\u0434\u0451\u0442 \u043F\u043E \u0441\u043E\u0445\u0440\u0430\u043D\u0451\u043D\u043D\u043E\u043C\u0443`);
     return saved;
   }
@@ -2156,6 +2330,7 @@ function buildAgentFlow(options, modules = {}) {
     return remember(chatId, await pinned);
   }
   const runtime = {
+    confirmations,
     store,
     now,
     logError,
@@ -2239,7 +2414,7 @@ function buildAgentFlow(options, modules = {}) {
       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)}`);
     }
   }
-  async function deliverFirstText(ownerId, chatId, messageId, condition, text) {
+  async function deliverFirstText(ownerId, chatId, messageId, condition, text, guarded2 = false) {
     for (let attempt = 0; ; attempt += 1) {
       const result = await (await portOf({ ownerId, chatId })).deliverNotices({
         ownerId,
@@ -2247,7 +2422,8 @@ function buildAgentFlow(options, modules = {}) {
         notices: [{ kind: "app", name: "flow_judge", title: `\u041F\u0440\u043E\u0432\u0435\u0440\u043A\u0430 \u0440\u0430\u0437\u0433\u043E\u0432\u043E\u0440\u0430: ${condition}` }],
         wakeAgent: true,
         deliveryKey: `flow:${chatId}:judge:${messageId}`,
-        reply: { text }
+        // Guarded decision может быть отозван после judge: готовый reply обошёл бы результат prepareTurn.
+        ...!guarded2 && { reply: { text } }
       });
       if (result.status !== "busy") return;
       if (attempt >= DELIVERY_RETRY_MS.length) return;
@@ -2258,7 +2434,8 @@ function buildAgentFlow(options, modules = {}) {
     const { ownerId, chatId, messageId } = result;
     const pinned = await chatFlow(ownerId, chatId);
     if (!pinned) return;
-    const { values } = await (await portOf({ ownerId, chatId })).getChatState(ownerId, chatId);
+    const service = await portOf({ ownerId, chatId });
+    const { values, atMessageId } = await service.getChatState(ownerId, chatId);
     const run = storedRun(values[FLOW_STATE_KEY]);
     if (!run || run.answerId !== messageId) return;
     await clearPlacement(chatId);
@@ -2269,7 +2446,30 @@ function buildAgentFlow(options, modules = {}) {
     const state = stateById(pinned.flow, run.state);
     if (!state || isFinal(state)) return;
     const conditions = judgeExits(pinned.flow, run.state);
-    if (conditions.length === 0) return;
+    const withConfirmations = confirmations.forState(pinned.flowId, run.state).length > 0 || conditions.some(({ exitId }) => confirmations.guardFor(pinned.flowId, run.state, exitId));
+    if (conditions.length === 0 && !withConfirmations) return;
+    if (withConfirmations) {
+      const checked = await judgeConfirmations({
+        confirmations,
+        pinned,
+        run,
+        result,
+        port: service,
+        atMessageId,
+        judge: judge(),
+        threshold: options.judge.threshold ?? 0.7,
+        now: chatTime(run, now()),
+        conditions,
+        goal: stateGoal(state.instructions),
+        messages: await history(ownerId, chatId, { run, answer: { id: messageId, parts: result.parts } })
+      });
+      if (!checked.saved || !checked.transition) return;
+      const transition2 = checked.transition;
+      if (!confirmations.guardFor(pinned.flowId, run.state, transition2.exitId)) await store.addPending(chatId, { kind: "transition", key: `judge:${messageId}`, transition: transition2, branchHead: messageId });
+      const first2 = exactFirstText(pinned.flow, transition2.to);
+      if (first2) await deliverFirstText(ownerId, chatId, messageId, conditions.find((item) => item.exitId === transition2.exitId).text, first2, Boolean(confirmations.guardFor(pinned.flowId, run.state, transition2.exitId)));
+      return;
+    }
     const verdicts = await judge().checkAll({
       ownerId,
       chatId,
@@ -2287,6 +2487,34 @@ function buildAgentFlow(options, modules = {}) {
     const first = exactFirstText(pinned.flow, transition.to);
     if (first) await deliverFirstText(ownerId, chatId, messageId, conditions.find((item) => item.exitId === met.exitId).text, first);
   }
+  async function revokeConfirmation(input) {
+    if (!input.reason?.trim() || input.reason.length > 1e3) throw new TypeError("revokeConfirmation: reason \u2014 \u043D\u0435\u043F\u0443\u0441\u0442\u0430\u044F \u0441\u0442\u0440\u043E\u043A\u0430 \u0434\u043E 1000 \u0437\u043D\u0430\u043A\u043E\u0432");
+    if (typeof input.idempotencyKey !== "string" || !input.idempotencyKey.trim() || input.idempotencyKey.length > 180) throw new TypeError("revokeConfirmation: idempotencyKey \u2014 \u043D\u0435\u043F\u0443\u0441\u0442\u0430\u044F \u0441\u0442\u0440\u043E\u043A\u0430 \u0434\u043E 180 \u0437\u043D\u0430\u043A\u043E\u0432");
+    const pinned = await chatFlow(input.ownerId, input.chatId);
+    if (!pinned || pinned.flowId !== input.flowId) return { status: "not_found" };
+    const spec = confirmations.specFor(input.flowId, input);
+    if (!spec) return { status: "stale" };
+    const service = await portOf(input);
+    const commit2 = flowStateCommitter2(service);
+    if (!commit2) throw new Error("confirmations: \u0441\u043B\u0443\u0436\u0431\u0430 \u0447\u0430\u0442\u0430 \u043D\u0435 \u043F\u0440\u0435\u0434\u043E\u0441\u0442\u0430\u0432\u043B\u044F\u0435\u0442 \u0432\u043D\u0443\u0442\u0440\u0435\u043D\u043D\u044E\u044E flows capability");
+    const snapshot = await service.getChatState(input.ownerId, input.chatId);
+    const run = storedRun(snapshot.values[FLOW_STATE_KEY]);
+    if (!run) return { status: "not_found" };
+    const old = run.confirmations?.[spec.key];
+    if (old && (old.scope?.ownerId !== input.ownerId || old.scope.chatId !== input.chatId || old.scope.flowId !== input.flowId)) return { status: "stale" };
+    if (old?.status === "revoked" && old.operationKey === input.idempotencyKey) {
+      if (old.reason !== input.reason || old.revision !== input.revision) throw new TypeError("revokeConfirmation: idempotencyKey \u0443\u0436\u0435 \u0438\u0441\u043F\u043E\u043B\u044C\u0437\u043E\u0432\u0430\u043D \u0441 \u0434\u0440\u0443\u0433\u0438\u043C payload");
+      return { status: "same", atMessageId: snapshot.atMessageId };
+    }
+    if (snapshot.atMessageId !== input.expectedAtMessageId || old && (old.revision !== spec.revision || old.criterionHash !== confirmationHash(spec))) return { status: "stale" };
+    const scope = { ownerId: input.ownerId, chatId: input.chatId, flowId: input.flowId };
+    const { checkedTransition, ...withoutDecision } = run;
+    const next = { ...withoutDecision, ...checkedTransition && checkedTransition.requires.key !== spec.key && { checkedTransition }, confirmations: {
+      ...run.confirmations,
+      [spec.key]: { key: spec.key, revision: spec.revision, status: "revoked", versionId: pinned.versionId, scope, criterionHash: confirmationHash(spec), revokedAt: chatTime(run, now()), afterMessageId: run.answerId ?? null, reason: input.reason, operationKey: input.idempotencyKey }
+    } };
+    return commit2({ ...scope, revision: confirmations.revision(input.flowId), expectedAtMessageId: input.expectedAtMessageId, idempotencyKey: `revoke:${input.idempotencyKey}`, flow: next });
+  }
   async function buttonPressed(context) {
     const pinned = await chatFlow(context.ownerId, context.chatId);
     if (!pinned) return;
@@ -2418,7 +2646,13 @@ function buildAgentFlow(options, modules = {}) {
     const transitions = [];
     const input = { now: at, card: await runtime.cardValues(ownerId), out: transitions, onChainLimit: () => {
     }, timeZone };
-    run = withPending(pinned.flow, run, record?.pending ?? [], input);
+    const decision = run.checkedTransition;
+    if (decision && decision.versionId === pinned.versionId && decision.answerId === run.answerId && decision.transition.from === run.state && confirmations.allows({ ownerId, chatId, flowId: pinned.flowId }, run, decision.transition.exitId)) {
+      const { checkedTransition, ...withoutDecision } = run;
+      run = advance(pinned.flow, withoutDecision, pendingEvent(decision.transition, timeZone), input);
+    }
+    const pending = (record?.pending ?? []).filter((change) => change.kind !== "transition" || !confirmations.guardFor(pinned.flowId, change.transition.from, change.transition.exitId));
+    run = withPending(pinned.flow, run, pending, input);
     const schedule = pinned.flow.schedule;
     if (record?.endedAt) run = endedRun(pinned.flow, run, { endedAt: Date.parse(record.endedAt), endReason: record.endReason ?? "final" });
     const { answerId: _answerId, firstReasons: _firstReasons, ...plain } = run;
@@ -2510,7 +2744,7 @@ ${rules}`;
                 } 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)}`);
                 }
-                await reschedule(input.ownerId, input.chatId, run, input.atMessageId);
+                await reschedule(input.ownerId, input.chatId, run, input.reason === "flowCommit" ? run.answerId ?? null : input.atMessageId);
               })();
               track(moved);
               await moved;
@@ -2549,10 +2783,14 @@ ${rules}`;
     noteStaffReply: (input) => pauses().noteStaffReply(input),
     reportDelivery: (input) => delivery().report(input),
     readRun,
+    revokeConfirmation,
+    previewMigration: (input) => previewConfirmedMigration(input, { store, confirmations, portFor: portOf }),
     chatsByState: (flowId, options2) => migrator().chatsByState(flowId, options2),
     async migrateChats(input) {
       try {
-        return await migrator().migrateChats(input);
+        if (!input.requiresConfirmation) return await migrator().migrateChats(input);
+        const preview = await previewConfirmedMigration({ ...input, requiresConfirmation: input.requiresConfirmation }, { store, confirmations, portFor: portOf });
+        return await migrator().migrateChats({ ...input, chatIds: preview.eligible, filter: void 0 });
       } finally {
         forgetPorts();
       }