@ykurilov/agent-chat-flows 0.63.2 → 0.65.0

package/dist/index.js

@@ -1,32 +1,61 @@
 import {
   TIME_ZONE_TASK_ID,
-  dayClosedToday,
-  firstMessageSlot,
   flowJsonSchema,
-  frameState,
-  hardFrameText,
   hasSideTasks,
-  humanMessagesToday,
-  migrateRun,
   openSideTasks,
-  resolveFirstMessages,
   sideTaskById,
   sideTaskFieldKnown,
   sideTaskRecord,
   sideTaskStanding
-} from "./chunk-H3AN5YUN.js";
+} from "./chunk-L7XNC3RB.js";
 import {
   FACT_PREFIX,
+  FIRST_MESSAGE_RETRY_MS,
+  FLOW_DEADLINE_NOTICE,
+  FLOW_EVENT_NOTICE,
+  FLOW_TIMER_NOTICE,
+  FlowTestClockError,
   MAX_FACTS,
   MAX_FACT_LENGTH,
+  UNKNOWN_TIME_ZONE,
+  advance,
+  advanceTestClock,
+  afterEndOf,
+  chainLimitMessage,
+  chatRun,
+  chatTime,
+  chatWriteBlock,
   clientCardBlock,
   clientFactStore,
+  createChatTimeZones,
+  createFirstMessageRules,
+  createFlowFinish,
+  createFlowTimeZones,
+  currentRun,
+  endedRun,
+  exactFirstText,
   factEntry,
   factId,
   fieldValueText,
+  firstReasonsNotice,
+  flowPrepareTurn,
+  flowTestChatData,
+  ianaTimeZone,
   isFactEntry,
-  sameFact
-} from "./chunk-KGWXTWBZ.js";
+  judgeExits,
+  pageTimeZone,
+  personTimeZone,
+  reportTransition,
+  runOutsideTurn,
+  sameFact,
+  silentMsOf,
+  stateCard,
+  stateGoal,
+  storedRun,
+  testChatOffset,
+  transitionReport,
+  withPending
+} from "./chunk-KRZMJJKG.js";
 import {
   AGENT_FLOW_FORMAT,
   AGENT_FLOW_FORMAT_VERSION,
@@ -69,17 +98,21 @@ import {
   dayStartHoldUntil,
   deadlineAt,
   deferredWake,
-  describeCondition,
   dueReasons,
   endingWake,
   fieldById,
   fieldValueFits,
+  firstMessageSlot,
   flowDay,
+  frameState,
+  hardFrameText,
+  humanMessagesToday,
   isFieldStale,
   isFinal,
   isTouch,
   localDay,
   migrateFlow,
+  migrateRun,
   nextDayStartAfter,
   nextDue,
   nextFirstMessageAfter,
@@ -90,10 +123,11 @@ import {
   noteHumanMessage,
   noteRejectedClaim,
   noteSideQuestion,
-  overdueOnEntry,
   parseBooleanAnswer,
+  parseDuration,
   parseFlow,
   placeOfPath,
+  resolveFirstMessages,
   returnTarget,
   sameText,
   sideQuestion,
@@ -105,7 +139,7 @@ import {
   withDayAnchor,
   withNudgeStep,
   withoutUndeliveredTouch
-} from "./chunk-LT4QELAZ.js";
+} from "./chunk-7VR4YNTJ.js";
 import {
   appliedInTime,
   byVersionAndState,
@@ -172,6 +206,42 @@ function turnToolNames(source, catalog, input) {
   }
 }
 
+// src/runtime/notice-screen.ts
+var TIMER_FIELDS = ["type", "from", "days", "day", "at", "amount", "unit"];
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var scalar = (value) => typeof value === "string" || typeof value === "number";
+function screenReason(reason) {
+  if (!isRecord(reason) || typeof reason.kind !== "string") return void 0;
+  return {
+    kind: reason.kind,
+    ...reason.kind === "daily" && typeof reason.at === "string" && { at: reason.at },
+    ...reason.kind === "night_messages" && typeof reason.count === "number" && { count: reason.count }
+  };
+}
+function screenWhen(when) {
+  if (!isRecord(when) || when.type !== "timer") return void 0;
+  return Object.fromEntries(TIMER_FIELDS.flatMap((field) => scalar(when[field]) ? [[field, when[field]]] : []));
+}
+function screenExit(exit) {
+  if (!isRecord(exit)) return void 0;
+  const when = screenWhen(exit.when);
+  const stateTitle = typeof exit.stateTitle === "string" ? exit.stateTitle : void 0;
+  if (!when && stateTitle === void 0) return void 0;
+  return { ...stateTitle !== void 0 && { stateTitle }, ...when && { when } };
+}
+function flowNoticeScreenData(data) {
+  if (!isRecord(data) || !Array.isArray(data.reasons)) return void 0;
+  const reasons = data.reasons.flatMap((reason) => screenReason(reason) ?? []);
+  if (reasons.length === 0) return void 0;
+  const exit = screenExit(data.exit);
+  return {
+    reasons,
+    ...typeof data.silentMs === "number" && Number.isFinite(data.silentMs) && { silentMs: data.silentMs },
+    ...exit && { exit }
+  };
+}
+var FLOW_APP_NOTICE_VIEWS = { [FLOW_TIMER_NOTICE]: flowNoticeScreenData, [FLOW_DEADLINE_NOTICE]: flowNoticeScreenData };
+
 // src/prompt/rules/time-zone.ts
 var TIME_ZONE_RULES = `## \u0414\u043D\u0438 \u0438 \u0432\u0440\u0435\u043C\u044F
 
@@ -263,184 +333,9 @@ function afterEndRules(flow) {
 ${shared}` : AFTER_END_RULES;
 }
 
-// src/prompt/state-card.ts
-function judgeExits(flow, stateId) {
-  const state = stateById(flow, stateId);
-  if (!state) return [];
-  return activeExits(flow, state).flatMap(({ exit }) => exit.when.type === "judge" ? [{ exitId: exit.id, text: exit.when.text }] : []);
-}
-function stateGoal(instructions) {
-  return instructions.split("\n")[0].trim();
-}
-function stateCard(flow, run, present) {
-  const state = stateById(flow, run.state);
-  if (!state) return `\u0421\u043E\u0441\u0442\u043E\u044F\u043D\u0438\u0435 \xAB${run.state}\xBB \u0432 \u0441\u0446\u0435\u043D\u0430\u0440\u0438\u0438 \u043D\u0435 \u043D\u0430\u0439\u0434\u0435\u043D\u043E: \u0432\u0435\u0434\u0438 \u0440\u0430\u0437\u0433\u043E\u0432\u043E\u0440 \u043F\u043E \u043E\u0431\u0449\u0438\u043C \u043F\u0440\u0430\u0432\u0438\u043B\u0430\u043C.`;
-  const [goal = "", ...rest] = state.instructions.split("\n");
-  const lines = [`\u0421\u043E\u0441\u0442\u043E\u044F\u043D\u0438\u0435: \xAB${state.title}\xBB`, `\u0426\u0435\u043B\u044C: ${goal.trim()}`];
-  const how = rest.join("\n").trim();
-  if (how) lines.push("", how);
-  const fields = state.learn.map((id) => fieldById(flow, id)).flatMap((found) => found ? [`- ${found.field.name}: ${found.field.about}`] : []);
-  if (fields.length > 0) lines.push("", "\u0423\u0437\u043D\u0430\u0442\u044C \u0437\u0434\u0435\u0441\u044C:", ...fields);
-  const conditions = judgeExits(flow, state.id);
-  if (isFinal(state)) {
-    lines.push("", "\u042D\u0442\u043E \u043F\u043E\u0441\u043B\u0435\u0434\u043D\u0435\u0435 \u0441\u043E\u0441\u0442\u043E\u044F\u043D\u0438\u0435 \u0441\u0446\u0435\u043D\u0430\u0440\u0438\u044F: \u0443\u0441\u043B\u043E\u0432\u0438\u0439 \u0432\u044B\u0445\u043E\u0434\u0430 \u043D\u0435\u0442.");
-  } else if (conditions.length > 0) {
-    lines.push("", "\u0423\u0441\u043B\u043E\u0432\u0438\u044F \u0432\u044B\u0445\u043E\u0434\u0430 (\u043D\u043E\u043C\u0435\u0440 \u2014 \u0434\u043B\u044F flow_exit):", ...conditions.map((condition, index) => `${index + 1}. ${condition.text}`));
-  }
-  const inSet = (name) => !present || present.has(name);
-  const tools = state.tools.filter(inSet);
-  if (tools.length > 0) lines.push("", `\u0418\u043D\u0441\u0442\u0440\u0443\u043C\u0435\u043D\u0442\u044B \u044D\u0442\u043E\u0433\u043E \u0441\u043E\u0441\u0442\u043E\u044F\u043D\u0438\u044F: ${tools.join(", ")}.`);
-  const unavailable = flow.tools.filter((name) => inSet(name) && !state.tools.includes(name));
-  if (unavailable.length > 0) lines.push(`\u0421\u0435\u0439\u0447\u0430\u0441 \u043D\u0435\u0434\u043E\u0441\u0442\u0443\u043F\u043D\u044B: ${unavailable.join(", ")}.`);
-  return lines.join("\n");
-}
-
 // src/runtime/note-tools.ts
 import { tool } from "ai";
 import { z } from "zod";
-
-// src/runtime/flow-events.ts
-async function reportTransition(handler, event, logError) {
-  if (!handler) return;
-  try {
-    await handler(event);
-  } catch (error) {
-    logError(`[\u0441\u0446\u0435\u043D\u0430\u0440\u0438\u0439] \u0447\u0430\u0442=${event.chatId} onTransition ${event.from} \u2192 ${event.to} \u0443\u043F\u0430\u043B: ${error instanceof Error ? error.message : String(error)}`);
-  }
-}
-function storedRun(value) {
-  return value && typeof value === "object" && typeof value.state === "string" ? value : null;
-}
-function currentRun(flow, values, now) {
-  return storedRun(values?.[FLOW_STATE_KEY]) ?? startRun(flow, now);
-}
-function placedRun(flow, placement, now, timeZone) {
-  const start = startRun(flow, now);
-  const state = placement.stateId !== void 0 && stateById(flow, placement.stateId) || stateById(flow, flow.start);
-  const startedAt = placement.startedAt ?? now;
-  const enteredAt = placement.enteredAt ?? placement.startedAt ?? now;
-  return {
-    ...start,
-    state: state.id,
-    startedAt,
-    enteredAt,
-    path: [{ state: state.id, at: enteredAt, tags: state.tags, from: null, exitId: null, decidedBy: "start" }],
-    ...placement.lastHumanAt !== void 0 && { lastHumanAt: placement.lastHumanAt },
-    ...placement.lastAgentAt !== void 0 && { lastAgentAt: placement.lastAgentAt },
-    ...placement.nudgeStep !== void 0 && { nudgeStep: placement.nudgeStep },
-    ...placement.humanToday && flow.schedule && timeZone && { dayCounts: { [dayInProgress(placement.humanToday.at, timeZone, flow.schedule)]: placement.humanToday.count } }
-  };
-}
-var msOf = (value) => value === void 0 ? void 0 : Date.parse(value);
-function recordPlacement(record) {
-  const placement = record.placement;
-  if (!placement) return null;
-  const lastHumanAt = msOf(placement.lastHumanAt);
-  const lastAgentAt = msOf(placement.lastAgentAt);
-  return {
-    stateId: record.stateId,
-    startedAt: Date.parse(placement.startedAt),
-    enteredAt: Date.parse(placement.enteredAt),
-    ...lastHumanAt !== void 0 && { lastHumanAt },
-    ...lastAgentAt !== void 0 && { lastAgentAt },
-    ...placement.nudgeStep !== void 0 && { nudgeStep: placement.nudgeStep },
-    ...placement.humanToday && { humanToday: { at: Date.parse(placement.humanToday.at), count: placement.humanToday.count } }
-  };
-}
-function chatRun(flow, values, record, now, timeZone) {
-  const stored = storedRun(values?.[FLOW_STATE_KEY]);
-  if (stored) return stored;
-  const placement = record ? recordPlacement(record) : null;
-  return placement ? placedRun(flow, placement, now, timeZone) : startRun(flow, now);
-}
-async function personTimeZone(runtime, chat) {
-  const known = runtime.timeZones ? await runtime.timeZones.of(chat.ownerId, chat.chatId) : (await runtime.store.getChat(chat.chatId))?.timeZone;
-  return known || runtime.defaultTimeZone || Intl.DateTimeFormat().resolvedOptions().timeZone;
-}
-async function runOutsideTurn(runtime, chat, flow, values, now, record) {
-  const stored = storedRun(values?.[FLOW_STATE_KEY]);
-  if (stored) return stored;
-  const found = record === void 0 ? await runtime.store.getChat(chat.chatId) : record;
-  if (!found?.placement) return startRun(flow, now);
-  const timeZone = runtime.timeZones ? await runtime.timeZones.of(chat.ownerId, chat.chatId) : found.timeZone || void 0;
-  return chatRun(flow, values, found, now, timeZone);
-}
-function advance(flow, run, event, input) {
-  let current = run;
-  let step = event;
-  let entered = false;
-  let stopped = false;
-  while (step) {
-    const transition = nextTransition(flow, current, step, input.now);
-    if (!transition) {
-      if (current.chain >= FLOW_CHAIN_LIMIT && nextTransition(flow, { ...current, chain: 0 }, step, input.now)) {
-        if (!stopped) input.onChainLimit(current);
-        stopped = true;
-      }
-      const overdue = entered && !stopped && step.type === "data" ? overdueOnEntry(flow, current, input.now, input.timeZone) : null;
-      step = overdue ? { type: "timer", exitId: overdue, timeZone: input.timeZone } : null;
-      continue;
-    }
-    current = applyTransition(flow, current, transition);
-    input.out.push(transition);
-    entered = true;
-    step = { type: "data", card: input.card };
-  }
-  return current;
-}
-function pendingEvent(transition, timeZone) {
-  if (transition.decidedBy === "timer") return { type: "timer", exitId: transition.exitId, timeZone };
-  return { type: "verdict", exitId: transition.exitId, probability: transition.probability ?? 1, decidedBy: "judge" };
-}
-function withPending(flow, run, pending, input) {
-  let current = run;
-  for (const change of pending) {
-    if (change.kind === "transition") {
-      if (change.branchHead !== run.answerId || current.state !== change.transition.from) continue;
-      current = advance(flow, current, pendingEvent(change.transition, input.timeZone), input);
-    } else if (change.kind === "event") {
-      current = advance(flow, current, { type: "event", event: "app", name: change.name }, input);
-    }
-  }
-  return current;
-}
-var chainLimitMessage = (chatId, run) => `[\u0441\u0446\u0435\u043D\u0430\u0440\u0438\u0439] \u0447\u0430\u0442=${chatId} ${FLOW_CHAIN_LIMIT} \u043F\u0435\u0440\u0435\u0445\u043E\u0434\u043E\u0432 \u043F\u043E\u0434\u0440\u044F\u0434 \u0431\u0435\u0437 \u043E\u0442\u0432\u0435\u0442\u0430 \u0430\u0433\u0435\u043D\u0442\u0430, \u0434\u0432\u0438\u0436\u043E\u043A \u043E\u0441\u0442\u0430\u043D\u043E\u0432\u043B\u0435\u043D \u0432 \xAB${run.state}\xBB`;
-function exitById(flow, exitId) {
-  for (const state of flow.states) {
-    const found = state.exits.find((exit) => exit.id === exitId);
-    if (found) return found;
-  }
-  return flow.anyState.exits.find((exit) => exit.id === exitId);
-}
-function exactFirstText(flow, stateId) {
-  return stateById(flow, stateId)?.firstMessage ?? null;
-}
-var sayExactly = (text) => `\u041F\u0435\u0440\u0432\u043E\u0435 \u0441\u043E\u043E\u0431\u0449\u0435\u043D\u0438\u0435 \u044D\u0442\u043E\u0433\u043E \u0441\u043E\u0441\u0442\u043E\u044F\u043D\u0438\u044F \u2014 \u0441\u043A\u0430\u0436\u0438 \u0440\u043E\u0432\u043D\u043E \u044D\u0442\u043E: \xAB${text}\xBB`;
-function transitionNotice(flow, transitions) {
-  const lines = transitions.map((transition) => {
-    const exit = exitById(flow, transition.exitId);
-    const title = stateById(flow, transition.to)?.title ?? transition.to;
-    return `\u0421\u0440\u0430\u0431\u043E\u0442\u0430\u043B\u043E: ${exit ? describeCondition(flow, exit.when) : transition.exitId} \u2192 \xAB${title}\xBB.`;
-  });
-  const last = transitions.at(-1);
-  const first = exactFirstText(flow, last.to);
-  if (first) lines.push(sayExactly(first));
-  return {
-    kind: "app",
-    name: "flow_transition",
-    title: lines.join("\n"),
-    data: { from: transitions[0].from, to: last.to, exitIds: transitions.map((transition) => transition.exitId) }
-  };
-}
-function transitionReport(flow, run, transitions) {
-  const from = stateById(flow, transitions[0].from)?.title ?? transitions[0].from;
-  const lines = [`\u041F\u0435\u0440\u0435\u0445\u043E\u0434: \xAB${from}\xBB \u2192 \xAB${stateById(flow, run.state)?.title ?? run.state}\xBB. \u0421\u043E\u0441\u0442\u043E\u044F\u043D\u0438\u0435 \u0441\u043C\u0435\u043D\u0438\u043B\u043E\u0441\u044C, \u043F\u0440\u043E\u0434\u043E\u043B\u0436\u0430\u0439 \u043F\u043E \u043D\u043E\u0432\u043E\u0439 \u043A\u0430\u0440\u0442\u043E\u0447\u043A\u0435.`, "", stateCard(flow, run)];
-  const first = exactFirstText(flow, run.state);
-  if (first) lines.push("", sayExactly(first));
-  return lines.join("\n");
-}
-
-// src/runtime/note-tools.ts
 var FLOW_NOTE_TOOL = "flow_note";
 var CLIENT_CARD_TOOL = "client_card";
 var NO_FLOW = "\u0412 \u044D\u0442\u043E\u043C \u0447\u0430\u0442\u0435 \u043D\u0435\u0442 \u0441\u0446\u0435\u043D\u0430\u0440\u0438\u044F: \u0437\u0430\u043F\u0438\u0441\u044B\u0432\u0430\u0442\u044C \u043D\u0435\u043A\u0443\u0434\u0430, \u043F\u0440\u043E\u0434\u043E\u043B\u0436\u0430\u0439 \u0440\u0430\u0437\u0433\u043E\u0432\u043E\u0440.";
@@ -673,105 +568,6 @@ function createClientCard(store, now, adapter, logError = () => {
   };
 }
 
-// src/runtime/first-message-retry.ts
-var FIRST_MESSAGE_RETRY_MS = 36e5;
-var FIRST_MESSAGE_MIN_RETRY_MS = 6e4;
-
-// src/runtime/first-message-rules.ts
-function chatWriteBlock(chat, at, timeZone, schedule) {
-  if (chat.windowClosed) return { retryAt: null };
-  const pausedUntil = chat.pausedUntil ? Date.parse(chat.pausedUntil) : 0;
-  if (pausedUntil > at) return { retryAt: pausedUntil };
-  if (schedule && dayClosedToday(chat.dayClosedOn, at, timeZone, schedule)) return { retryAt: nextDayStartAfter(at, timeZone, schedule) };
-  return null;
-}
-function scenarioRules(rules, schedule) {
-  if (!schedule) return rules;
-  return {
-    quietHours: { from: schedule.nightFrom ?? rules.quietHours.from, to: schedule.dayStart },
-    maxPerDay: schedule.firstMessages?.maxPerDay ?? rules.maxPerDay
-  };
-}
-function createFirstMessageRules(setting, store) {
-  const rules = resolveFirstMessages(setting);
-  if (!rules) return null;
-  return {
-    async check({ ownerId, chatId, at, timeZone, schedule, chat }) {
-      const blocked = chat ? chatWriteBlock(chat, at, timeZone, schedule) : null;
-      if (blocked) return { allowed: false, retryAt: blocked.retryAt };
-      const sentToday = await store.countFirstMessages(ownerId, localDay(at, timeZone));
-      const slot = firstMessageSlot(scenarioRules(rules, schedule), { at, timeZone, sentToday });
-      if (!slot.allowed) return slot;
-      const answer = rules.canWriteNow ? await rules.canWriteNow({ ownerId, chatId, at: new Date(at) }) : true;
-      if (answer === true) return { allowed: true };
-      return { allowed: false, retryAt: retryAtOf(answer, at) };
-    },
-    async record({ ownerId, at, timeZone }) {
-      await store.addFirstMessage(ownerId, localDay(at, timeZone));
-    }
-  };
-}
-function retryAtOf(answer, at) {
-  if (answer === "never") return null;
-  const retryAt = typeof answer === "object" && answer !== null && answer.retryAt instanceof Date ? answer.retryAt.getTime() : Number.NaN;
-  if (!Number.isFinite(retryAt)) return at + FIRST_MESSAGE_RETRY_MS;
-  return Math.max(retryAt, at + FIRST_MESSAGE_MIN_RETRY_MS);
-}
-var UNKNOWN_TIME_ZONE = "";
-var serverTimeZone = () => Intl.DateTimeFormat().resolvedOptions().timeZone;
-function pageTimeZone(turnZone, appZone, sent) {
-  if (sent !== void 0) return sent;
-  return turnZone === (appZone ?? serverTimeZone()) ? null : turnZone;
-}
-function createChatTimeZones(input) {
-  const warned = /* @__PURE__ */ new Set();
-  return {
-    of(chatId, stored) {
-      if (stored) return stored;
-      if (input.defaultTimeZone) return input.defaultTimeZone;
-      const app = input.appTimeZone();
-      if (app) return app;
-      const server = serverTimeZone();
-      if (!warned.has(chatId)) {
-        warned.add(chatId);
-        input.warn(`[\u0441\u0446\u0435\u043D\u0430\u0440\u0438\u0439] \u0447\u0430\u0442=${chatId}: \u043F\u043E\u044F\u0441 \u0447\u0435\u043B\u043E\u0432\u0435\u043A\u0430 \u043D\u0435\u0438\u0437\u0432\u0435\u0441\u0442\u0435\u043D (\u043D\u0435\u0442 \u043D\u0438 \u0441\u043E \u0441\u0442\u0440\u0430\u043D\u0438\u0446\u044B, \u043D\u0438 defaultTimeZone, \u043D\u0438 agent.timeZone) \u2014 \u0442\u0438\u0445\u0438\u0435 \u0447\u0430\u0441\u044B \u0438 \xAB\u0432\u0440\u0435\u043C\u044F \u0441\u0443\u0442\u043E\u043A\xBB \u043F\u043E \u043F\u043E\u044F\u0441\u0443 \u0441\u0435\u0440\u0432\u0435\u0440\u0430 ${server}`);
-      }
-      return server;
-    }
-  };
-}
-function ianaTimeZone(value) {
-  if (!value.trim()) return null;
-  try {
-    return new Intl.DateTimeFormat("en-US", { timeZone: value.trim() }).resolvedOptions().timeZone;
-  } catch {
-    return null;
-  }
-}
-function createFlowTimeZones(input) {
-  const { store } = input;
-  const iso = () => new Date(input.now()).toISOString();
-  const readPerson = (ownerId) => input.people ? input.people.readTimeZone(ownerId) : store.readTimeZone(ownerId);
-  const writePerson = (ownerId, timeZone) => input.people ? input.people.writeTimeZone(ownerId, timeZone) : store.writeTimeZone(ownerId, timeZone, iso());
-  async function known(ownerId, chatId) {
-    const person = await readPerson(ownerId);
-    if (person) return person;
-    return (await store.getChat(chatId))?.timeZone || null;
-  }
-  return {
-    known,
-    fallback: input.fallback,
-    async of(ownerId, chatId) {
-      return await known(ownerId, chatId) ?? input.fallback(chatId);
-    },
-    async write(ownerId, chatId, timeZone) {
-      if (await readPerson(ownerId) !== timeZone) await writePerson(ownerId, timeZone);
-      const record = await store.getChat(chatId);
-      if (record && record.timeZone !== timeZone) await store.updateChat(chatId, { timeZone }, iso());
-    }
-  };
-}
-
 // src/runtime/decisions-client.ts
 function decisionsUrl(baseUrl) {
   const base = baseUrl.replace(/\/+$/, "");
@@ -1008,334 +804,11 @@ function errorText2(error) {
 import { randomUUID } from "crypto";
 import { ChatNotFoundError as ChatNotFoundError2, SpendingLimitReachedError } from "@ykurilov/agent-chat-core";
 
-// src/runtime/test-clock.ts
-var FLOW_TEST_CHAT_KEY = "flowTestChat";
-function flowTestChatData() {
-  return { [FLOW_TEST_CHAT_KEY]: { timeOffset: 0 } };
-}
-function testChatOffset(data) {
-  const mark = data?.[FLOW_TEST_CHAT_KEY];
-  if (!mark || typeof mark !== "object") return null;
-  const offset = mark.timeOffset;
-  return typeof offset === "number" && Number.isFinite(offset) ? offset : 0;
-}
-var chatTime = (run, serverNow) => serverNow + (run?.timeOffset ?? 0);
-var TURN_WAIT_LIMIT = 5;
-async function placeRun(runtime, port, chat, flow, now) {
-  const { values } = await port.getChatState(chat.ownerId, chat.chatId);
-  const stored = storedRun(values[FLOW_STATE_KEY]);
-  if (stored) return stored;
-  const record = await runtime.store.getChat(chat.chatId);
-  return record ? runOutsideTurn(runtime, chat, flow, values, now, record) : null;
-}
-async function msToNextDay(runtime, port, ownerId, chatId, offset) {
-  const pinned = await runtime.chatFlow(ownerId, chatId);
-  const schedule = pinned?.flow.schedule;
-  if (!pinned || !schedule) throw new Error("\u041F\u0435\u0440\u0435\u043C\u043E\u0442\u043A\u0430 \u0434\u043E \u0443\u0442\u0440\u0430: \u0443 \u0441\u0446\u0435\u043D\u0430\u0440\u0438\u044F \u043D\u0435 \u043D\u0430\u0441\u0442\u0440\u043E\u0435\u043D\u044B \xAB\u0414\u043D\u0438 \u0438 \u0432\u0440\u0435\u043C\u044F\xBB (schedule)");
-  const chatNow = runtime.now() + offset;
-  const run = await placeRun(runtime, port, { ownerId, chatId }, pinned.flow, chatNow);
-  if (!run) throw new Error("\u041F\u0435\u0440\u0435\u043C\u043E\u0442\u043A\u0430 \u0434\u043E \u0443\u0442\u0440\u0430: \u0432 \u0447\u0430\u0442\u0435 \u0435\u0449\u0451 \u043D\u0435 \u0431\u044B\u043B\u043E \u0445\u043E\u0434\u0430, \u0434\u043D\u0438 \u0441\u0446\u0435\u043D\u0430\u0440\u0438\u044F \u043D\u0435 \u043D\u0430\u0447\u0430\u043B\u0438\u0441\u044C");
-  const timeZone = runtime.timeZones ? await runtime.timeZones.of(ownerId, chatId) : "UTC";
-  return flowDay(run, chatNow, timeZone, schedule).nextDayStartAt - chatNow;
-}
-async function turnFinished(port, ownerId, chatId) {
-  for (let turn = 0; turn < TURN_WAIT_LIMIT; turn += 1) {
-    const stream = await port.subscribe?.(ownerId, chatId);
-    if (!stream) return;
-    for await (const _chunk of stream) ;
-  }
-}
-async function advanceTestClock(input) {
-  const { runtime, port, timers, ownerId, chatId, clock } = input;
-  const offset = testChatOffset(await port.getChatData(ownerId, chatId));
-  if (offset === null) throw new Error(`\u0427\u0430\u0442 ${chatId} \u043D\u0435 \u0442\u0435\u0441\u0442\u043E\u0432\u044B\u0439: \u0447\u0430\u0441\u044B \u043F\u0435\u0440\u0435\u043C\u0430\u0442\u044B\u0432\u0430\u044E\u0442\u0441\u044F \u0442\u043E\u043B\u044C\u043A\u043E \u0443 \u0442\u0435\u0441\u0442\u043E\u0432\u044B\u0445 \u0447\u0430\u0442\u043E\u0432`);
-  const ms = clock.to === "next_day_start" ? await msToNextDay(runtime, port, ownerId, chatId, offset) : clock.ms;
-  if (!Number.isFinite(ms) || ms <= 0) throw new Error("\u041F\u0435\u0440\u0435\u043C\u043E\u0442\u043A\u0430 \u0447\u0430\u0441\u043E\u0432: \u043D\u0443\u0436\u0435\u043D \u0441\u0434\u0432\u0438\u0433 \u0432\u043F\u0435\u0440\u0451\u0434, \u043C\u0441 \u0431\u043E\u043B\u044C\u0448\u0435 \u043D\u0443\u043B\u044F");
-  const timeOffset = offset + ms;
-  await port.updateChatData(ownerId, chatId, { [FLOW_TEST_CHAT_KEY]: { timeOffset } });
-  const pinned = timers && await runtime.chatFlow(ownerId, chatId);
-  if (!timers || !pinned) return { timeOffset };
-  const run = await placeRun(runtime, port, { ownerId, chatId }, pinned.flow, runtime.now() + timeOffset);
-  if (!run) return { timeOffset };
-  await timers.reschedule({ ownerId, chatId, run: { ...run, timeOffset }, branchHead: run.answerId ?? null });
-  await timers.tick();
-  await turnFinished(port, ownerId, chatId);
-  return { timeOffset };
-}
-
-// src/runtime/flow-finish.ts
-var FLOW_DEADLINE_NOTICE = "flow_deadline";
-var DEADLINE_REASON = { kind: "timer", text: "\u0441\u0440\u043E\u043A \u0432\u044B\u0448\u0435\u043B" };
-var FAREWELL_NOTICE = "\u0421\u0440\u043E\u043A \u043F\u0440\u043E\u0433\u0440\u0430\u043C\u043C\u044B \u0432\u044B\u0448\u0435\u043B. \u041F\u043E\u043F\u0440\u043E\u0449\u0430\u0439\u0441\u044F \u0441 \u0447\u0435\u043B\u043E\u0432\u0435\u043A\u043E\u043C \u043E\u0434\u043D\u0438\u043C \u0441\u043E\u043E\u0431\u0449\u0435\u043D\u0438\u0435\u043C: \u043A\u043E\u0440\u043E\u0442\u043A\u043E \u043F\u043E\u0434\u0432\u0435\u0434\u0438 \u0438\u0442\u043E\u0433 \u0438 \u0441\u043A\u0430\u0436\u0438, \u0447\u0442\u043E \u0434\u0430\u043B\u044C\u0448\u0435.";
-function afterEndOf(flow) {
-  return flow.afterEnd ?? "reply";
-}
-var finalEndsChat = (flow) => flow.schedule !== void 0 || flow.afterEnd !== void 0;
-function deadlineTransition(flow, run, at) {
-  const to = flow.schedule?.deadlineState;
-  const state = to === void 0 ? void 0 : stateById(flow, to);
-  if (!state || run.state === state.id) return null;
-  return { from: run.state, to: state.id, exitId: FLOW_DEADLINE_EXIT, decidedBy: "timer", tags: state.tags, at, reason: DEADLINE_REASON };
-}
-function endedRun(flow, run, ended) {
-  if (run.endedAt !== void 0) return run;
-  const transition = ended.endReason === "deadline" ? deadlineTransition(flow, run, ended.endedAt) : null;
-  const moved = transition ? applyTransition(flow, run, transition) : run;
-  return { ...moved, endedAt: ended.endedAt, endReason: ended.endReason };
-}
-function createFlowFinish(input) {
-  const { runtime } = input;
-  async function report(event) {
-    const { onFinish } = input;
-    if (!onFinish) return;
-    const { schedule } = event.pinned.flow;
-    let day = null;
-    if (schedule) {
-      const timeZone = await runtime.timeZones?.of(event.ownerId, event.chatId) ?? "UTC";
-      day = flowDay(event.run, event.at, timeZone, schedule).day;
-      if (schedule.lengthDays !== void 0) day = Math.min(day, schedule.lengthDays);
-    }
-    const { answerId: _answerId, firstReasons: _firstReasons, ...run } = event.run;
-    const finish = {
-      ownerId: event.ownerId,
-      chatId: event.chatId,
-      flowId: event.pinned.flowId,
-      versionId: event.pinned.versionId,
-      reason: event.reason,
-      ...event.outcome !== void 0 && { outcome: event.outcome },
-      day,
-      state: event.run.state,
-      tags: stateById(event.pinned.flow, event.run.state)?.tags ?? [],
-      run,
-      at: new Date(event.at)
-    };
-    const work = Promise.resolve().then(() => onFinish(finish)).catch((error) => runtime.logError(`[\u0441\u0446\u0435\u043D\u0430\u0440\u0438\u0439] \u0447\u0430\u0442=${event.chatId} onFinish \u0443\u043F\u0430\u043B: ${error instanceof Error ? error.message : String(error)}`));
-    if (runtime.track) runtime.track(work);
-    else await work;
-  }
-  async function close(chatId, reason, at) {
-    const before = await runtime.store.getChat(chatId);
-    if (!before || before.endedAt !== null) return false;
-    const after = await runtime.store.endChat(chatId, { reason, at: new Date(at).toISOString() });
-    return after !== null && after.endReason === reason && Date.parse(after.endedAt ?? "") === at;
-  }
-  return {
-    async afterTransitions({ ownerId, chatId, pinned, run, transitions }) {
-      const final = transitions.find((transition) => {
-        const state = stateById(pinned.flow, transition.to);
-        return state !== void 0 && isFinal(state);
-      });
-      if (!final) return;
-      if (finalEndsChat(pinned.flow) && !await close(chatId, "final", final.at)) return;
-      await report({ ownerId, chatId, pinned, run, reason: "final", at: final.at });
-    },
-    async deadline({ ownerId, chatId, pinned, run, at }) {
-      const ended = await close(chatId, "deadline", at);
-      const transition = deadlineTransition(pinned.flow, run, at);
-      let next = run;
-      if (ended && transition) {
-        next = applyTransition(pinned.flow, run, transition);
-        await runtime.afterTransitions({ ownerId, chatId, pinned, run: next, transitions: [transition] });
-      }
-      if (ended) await report({ ownerId, chatId, pinned, run: next, reason: "deadline", at });
-      return { run: endedRun(pinned.flow, next, { endedAt: at, endReason: "deadline" }), ended };
-    },
-    async farewell({ ownerId, chatId, pinned, at, timeZone, port, firstMessages, delivery }) {
-      const schedule = pinned.flow.schedule;
-      if (!schedule?.farewellOnDeadline) return;
-      const record = await runtime.store.getChat(chatId);
-      const chat = record ? { dayClosedOn: record.dayClosedOn, pausedUntil: record.pausedUntil, windowClosed: record.windowClosed } : void 0;
-      const allowed = firstMessages ? await firstMessages.check({ ownerId, chatId, at, timeZone, schedule, ...chat && { chat } }) : { allowed: true };
-      if (!allowed.allowed) return;
-      const text = schedule.farewellText?.trim();
-      const result = await port.deliverNotices({
-        ownerId,
-        chatId,
-        notices: [{ kind: "app", name: FLOW_DEADLINE_NOTICE, title: FAREWELL_NOTICE, data: { reasons: [{ kind: "farewell" }] } }],
-        wakeAgent: true,
-        deliveryKey: `flow:${chatId}:deadline`,
-        usageSource: "first_message",
-        maxServerTurnsInRow: false,
-        timeZone,
-        ...delivery?.own() && { awaitAnswer: true },
-        ...text && { reply: { text } }
-      });
-      if (result.status !== "delivered" || !result.turnStarted) return;
-      if (delivery) await delivery.afterFirstTurn({ ownerId, chatId, answer: result.answer, reasons: [{ kind: "farewell" }], at, timeZone });
-      else await firstMessages?.record({ ownerId, at, timeZone });
-    },
-    async end({ ownerId, chatId, pinned, run, reason, outcome, at }) {
-      const ended = await close(chatId, reason, at);
-      if (ended) await report({ ownerId, chatId, pinned, run, reason, ...outcome !== void 0 && { outcome }, at });
-      return { ended };
-    }
-  };
-}
-
-// src/runtime/prepare-turn.ts
-var FLOW_TIMER_NOTICE = "flow_timer";
-var FLOW_EVENT_NOTICE = "flow_event";
-var HUMAN_ACTIONS = /* @__PURE__ */ new Set(["send", "edit", "regenerate", "retry"]);
-var transitionKey = (transition) => `${transition.from}\0${transition.exitId}`;
-var errorText3 = (error) => error instanceof Error ? error.message : String(error);
-var dataOf = (notice) => notice.data && typeof notice.data === "object" ? notice.data : {};
-var firstReasonsOf = (notices) => notices.flatMap((notice) => {
-  if (notice.kind !== "app" || notice.name !== FLOW_TIMER_NOTICE && notice.name !== FLOW_DEADLINE_NOTICE) return [];
-  const { reasons } = dataOf(notice);
-  return Array.isArray(reasons) ? reasons : [];
-});
-function flowPrepareTurn(runtime, appTimeZone, finisher) {
-  return async (ctx) => {
-    if (ctx.audience === "group") return;
-    let pinned = await runtime.chatFlow(ctx.ownerId, ctx.chatId, ctx.chat);
-    if (!pinned) return;
-    const timeOffset = testChatOffset(ctx.chat.data);
-    const now = runtime.now() + (timeOffset ?? 0);
-    const transitions = [];
-    let card;
-    const applied = [];
-    const step = async (run2, event, out = transitions) => advance(pinned.flow, run2, event, {
-      now,
-      card: card ??= await runtime.cardValues(ctx.ownerId),
-      out,
-      onChainLimit: (stopped) => runtime.logError(chainLimitMessage(ctx.chatId, stopped)),
-      timeZone
-    });
-    const record = await runtime.store.getChat(ctx.chatId);
-    const page = pageTimeZone(ctx.timeZone, appTimeZone(), ctx.pageTimeZone);
-    const known = page ?? (runtime.timeZones ? await runtime.timeZones.known(ctx.ownerId, ctx.chatId) : record?.timeZone || null);
-    const timeZone = known ?? runtime.defaultTimeZone ?? ctx.timeZone;
-    let run = currentRun(pinned.flow, ctx.state, now);
-    const previousAnswer = run.answerId;
-    const pending = await runtime.store.takePending(ctx.chatId);
-    const appliedInTime2 = new Set(
-      pending.flatMap((change) => change.kind === "transition" && change.appliedAt !== void 0 && change.branchHead === previousAnswer ? [transitionKey(change.transition)] : [])
-    );
-    let restored = null;
-    const restore = () => restored ??= Promise.all(pending.map((change) => runtime.store.addPending(ctx.chatId, change)));
-    const onAbort = () => void restore().catch((error) => runtime.logError(`[\u0441\u0446\u0435\u043D\u0430\u0440\u0438\u0439] \u0447\u0430\u0442=${ctx.chatId} \u043E\u0436\u0438\u0434\u0430\u044E\u0449\u0435\u0435 \u043D\u0435 \u0432\u043E\u0437\u0432\u0440\u0430\u0449\u0435\u043D\u043E: ${errorText3(error)}`));
-    if (pending.length > 0) ctx.abortSignal.addEventListener("abort", onAbort, { once: true });
-    try {
-      return await applyTurn();
-    } catch (error) {
-      await restore();
-      throw error;
-    } finally {
-      ctx.abortSignal.removeEventListener("abort", onAbort);
-    }
-    async function applyTurn() {
-      const schedule = pinned.flow.schedule;
-      if (schedule) run = withDayAnchor(run, timeZone, schedule);
-      if (record?.endedAt) {
-        run = endedRun(pinned.flow, run, { endedAt: Date.parse(record.endedAt), endReason: record.endReason ?? "final" });
-      } else if (schedule && finisher) {
-        const deadline = deadlineAt(run, timeZone, schedule);
-        if (deadline !== null && deadline <= now) {
-          ({ run } = await finisher().deadline({ ownerId: ctx.ownerId, chatId: ctx.chatId, pinned, run, at: deadline, timeZone }));
-        }
-      }
-      const ended = run.endedAt !== void 0;
-      for (const change of ended ? [] : pending) {
-        if (change.kind === "migrate") {
-          const next = await runtime.chatFlow(ctx.ownerId, ctx.chatId);
-          if (next) {
-            run = { ...migrateRun(run, next.flow, change.map, now), answerId: previousAnswer };
-            pinned = next;
-          }
-        } else if (change.kind === "transition") {
-          if (change.branchHead !== previousAnswer || run.state !== change.transition.from) continue;
-          const out = [];
-          run = await step(run, pendingEvent(change.transition, timeZone), out);
-          for (const transition of out) (appliedInTime2.has(transitionKey(transition)) ? applied : transitions).push(transition);
-        } else {
-          run = await step(run, { type: "event", event: "app", name: change.name });
-        }
-      }
-      let touchBase = null;
-      for (const notice of ended ? [] : ctx.notices) {
-        if (notice.kind !== "app") continue;
-        const data = dataOf(notice);
-        if (notice.name === FLOW_TIMER_NOTICE) {
-          if (typeof data.undelivered === "string") run = withoutUndeliveredTouch(run, /* @__PURE__ */ new Set([data.undelivered])).run;
-          if (typeof data.exitId === "string") run = await step(run, { type: "timer", exitId: data.exitId, timeZone });
-          touchBase = { lastAgentAt: run.lastAgentAt, nudgeStep: run.nudgeStep ?? 0, ...run.nudgeStepOwn && { nudgeStepOwn: true }, agentAnswers: run.agentAnswers };
-          if (typeof data.nudgeStep === "number") run = withNudgeStep(run, data.nudgeStep, data.nudgeStepOwn === true);
-        } else if (notice.name === FLOW_EVENT_NOTICE && typeof data.name === "string") {
-          run = await step(run, { type: "event", event: "app", name: data.name });
-        }
-      }
-      if (!ctx.resumed && HUMAN_ACTIONS.has(ctx.action)) {
-        if (record?.windowClosed) await runtime.store.setWindowClosed(ctx.chatId, false);
-        run = noteHumanMessage(run, now, schedule ? dayInProgress(now, timeZone, schedule) : void 0, ctx.burstMessageIds?.length ?? 1);
-        if (!ended) run = await step(run, { type: "event", event: "message" });
-      }
-      if (ctx.action === "notice" && !ctx.resumed) run = { ...run, serverTurns: (run.serverTurns ?? 0) + 1 };
-      if (ctx.action !== "approval" && ctx.action !== "widget") run = noteAgentAnswer(run, now);
-      const { touch: earlierTouch, firstReasons: earlierReasons, ...withoutTouch } = run;
-      const continued = ctx.action === "approval" || ctx.action === "widget";
-      const touch = touchBase ? { answerId: ctx.messageId, at: now, ...touchBase } : continued ? earlierTouch : void 0;
-      const reasons = firstReasonsOf(ctx.notices);
-      const firstReasons = reasons.length > 0 ? reasons : continued ? earlierReasons : void 0;
-      run = { ...withoutTouch, answerId: ctx.messageId, ...timeOffset !== null && { timeOffset }, ...touch && { touch }, ...firstReasons && { firstReasons } };
-      if (ctx.abortSignal.aborted) {
-        await restore();
-        return void 0;
-      }
-      if (known && runtime.timeZones) await runtime.timeZones.write(ctx.ownerId, ctx.chatId, known);
-      else if (record && page && record.timeZone !== page) await runtime.store.updateChat(ctx.chatId, { timeZone: page }, new Date(runtime.now()).toISOString());
-      await runtime.afterTransitions({ ownerId: ctx.ownerId, chatId: ctx.chatId, pinned, run, transitions });
-      return {
-        set: { [FLOW_STATE_KEY]: run },
-        ...applied.length + transitions.length > 0 && { notices: [transitionNotice(pinned.flow, [...applied, ...transitions])] }
-      };
-    }
-  };
-}
-
-// src/runtime/first-reasons-notice.ts
-var REASON_LINES = {
-  morning: "\u041D\u0430\u0447\u0430\u043B\u0441\u044F \u043D\u043E\u0432\u044B\u0439 \u0434\u0435\u043D\u044C \u0441\u0446\u0435\u043D\u0430\u0440\u0438\u044F: \u0443\u043C\u0435\u0441\u0442\u043D\u043E \u0434\u043E\u0431\u0440\u043E\u0435 \u0443\u0442\u0440\u043E.",
-  silence: (step) => `\u0427\u0435\u043B\u043E\u0432\u0435\u043A \u043C\u043E\u043B\u0447\u0438\u0442 \u043F\u043E\u0441\u043B\u0435 \u0442\u0432\u043E\u0435\u0433\u043E \u0441\u043E\u043E\u0431\u0449\u0435\u043D\u0438\u044F (\u043A\u0430\u0441\u0430\u043D\u0438\u0435 ${step}).`,
-  daily: (at) => `\u041A\u0430\u0441\u0430\u043D\u0438\u0435 \u043F\u043E \u0440\u0430\u0441\u043F\u0438\u0441\u0430\u043D\u0438\u044E, ${at}.`,
-  nightMessages: (count) => `\u0427\u0435\u043B\u043E\u0432\u0435\u043A \u043D\u0430\u043A\u043E\u043F\u0438\u043B \u0441\u043E\u043E\u0431\u0449\u0435\u043D\u0438\u044F \u0431\u0435\u0437 \u043E\u0442\u0432\u0435\u0442\u0430 (${count}): \u043E\u0442\u0432\u0435\u0442\u044C \u043D\u0430 \u043D\u0438\u0445.`
-};
-var TASK = "\u0422\u044B \u043F\u0438\u0448\u0435\u0448\u044C \u0447\u0435\u043B\u043E\u0432\u0435\u043A\u0443 \u043F\u0435\u0440\u0432\u044B\u043C. \u041D\u0430\u043F\u0438\u0448\u0438 \u043E\u0434\u043D\u043E \u043A\u043E\u0440\u043E\u0442\u043A\u043E\u0435 \u0441\u043E\u043E\u0431\u0449\u0435\u043D\u0438\u0435: \u043D\u043E\u0432\u043E\u0435 \u0438 \u043F\u043E\u043B\u0435\u0437\u043D\u043E\u0435 \u0434\u043B\u044F \u0447\u0435\u043B\u043E\u0432\u0435\u043A\u0430 \u043F\u043E \u0442\u0435\u043C\u0435 \u0440\u0430\u0437\u0433\u043E\u0432\u043E\u0440\u0430, \u0431\u0435\u0437 \u043F\u043E\u0432\u0442\u043E\u0440\u0430 \u0443\u0436\u0435 \u0441\u043A\u0430\u0437\u0430\u043D\u043D\u043E\u0433\u043E \u0438 \u0431\u0435\u0437 \u0443\u043F\u0440\u0451\u043A\u043E\u0432 \u0437\u0430 \u043C\u043E\u043B\u0447\u0430\u043D\u0438\u0435.";
-var transitionLine = (flow, exitId) => {
-  const exit = exitById(flow, exitId);
-  return `\u0421\u0440\u0430\u0431\u043E\u0442\u0430\u043B\u043E: ${exit ? describeCondition(flow, exit.when) : exitId}`;
-};
-function reasonLine(reason) {
-  switch (reason.kind) {
-    case "morning":
-      return REASON_LINES.morning;
-    case "silence":
-      return REASON_LINES.silence(reason.step);
-    case "daily":
-      return REASON_LINES.daily(reason.at);
-    case "night_messages":
-      return REASON_LINES.nightMessages(reason.count);
-    default:
-      return null;
-  }
-}
-function firstReasonsNotice(flow, reasons, exitId, ownNudge = false) {
-  const silence = reasons.find((reason) => reason.kind === "silence");
-  const moved = exitId !== null && reasons.some((reason) => reason.kind === "transition");
-  const morning = reasons.some((reason) => reason.kind === "morning");
-  const nudgeStep = moved || morning ? 0 : silence?.kind === "silence" ? silence.step : void 0;
-  const own = ownNudge && silence !== void 0 && !moved && !morning;
-  const data = { ...moved && { exitId }, reasons: [...reasons], ...nudgeStep !== void 0 && { nudgeStep }, ...own && { nudgeStepOwn: true } };
-  const others = reasons.flatMap((reason) => reasonLine(reason) ?? []);
-  if (others.length === 0 && moved) return { kind: "app", name: FLOW_TIMER_NOTICE, title: transitionLine(flow, exitId), data };
-  const lines = [...moved ? [`${transitionLine(flow, exitId)}.`] : [], ...others, TASK];
-  return { kind: "app", name: FLOW_TIMER_NOTICE, title: lines.join("\n"), data };
-}
-
 // 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];
-var errorText4 = (error) => error instanceof Error ? error.message : String(error);
+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) {
@@ -1350,7 +823,7 @@ function createFlowDelivery(input) {
       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: ${errorText4(error)}`);
+      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) {
@@ -1402,7 +875,7 @@ function createFlowDelivery(input) {
     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: ${errorText4(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" };
     }
   }
@@ -1478,7 +951,7 @@ var TIMER_BATCH = 50;
 var TIMER_PARALLEL = 5;
 var DAY_MS = 864e5;
 var DEFAULT_FLOW_SERVER_TURNS_IN_ROW = 50;
-var errorText5 = (error) => error instanceof Error ? error.message : String(error);
+var errorText4 = (error) => error instanceof Error ? error.message : String(error);
 var isoOf2 = (at) => new Date(at).toISOString();
 var timerKey = (chatId, exitId, run) => `flow:${chatId}:${exitId}:${run.enteredAt}`;
 async function historyFacts(port, ownerId, chatId, answerId) {
@@ -1501,6 +974,10 @@ function createFlowTimers(input) {
   const owner = `flow-timers:${randomUUID()}`;
   let interval;
   let running = null;
+  const watchers = /* @__PURE__ */ new Map();
+  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 });
   async function placeOf2(record, chatPort, run, failedAt) {
     const pausedUntil = record.pausedUntil === null ? null : Date.parse(record.pausedUntil);
@@ -1625,11 +1102,14 @@ function createFlowTimers(input) {
       await store.setDue(chatId, 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;
+      fired(chatId, { kind: "deadline", stateId: deadlineState && stateById(flow, deadlineState) ? deadlineState : run.state });
       return;
     }
     if (due.giveUp) {
       await store.setDue(chatId, null);
       await input.onGiveUp?.({ record, flow, run, at });
+      fired(chatId, { kind: "give_up", stateId: run.state });
       return;
     }
     const transitions = [];
@@ -1678,7 +1158,7 @@ function createFlowTimers(input) {
       await defer(flow.schedule ? nextDayStartAfter(at, timeZone, flow.schedule) : at + DAY_MS);
       return;
     }
-    const reasonsNotice = firstReasonsNotice(flow, reasons, moved ? due.exitId : null, due.ownNudge);
+    const reasonsNotice = firstReasonsNotice(flow, reasons, moved ? due.exitId : null, due.ownNudge, silentMsOf(run, at));
     const notice = undelivered ? { ...reasonsNotice, data: { ...reasonsNotice.data, undelivered } } : reasonsNotice;
     const reply = moved ? exactFirstText(flow, next.state) : null;
     const delivery = input.delivery?.();
@@ -1710,6 +1190,7 @@ function createFlowTimers(input) {
     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 });
+    fired(chatId, { kind: reasons[0].kind, stateId: next.state, ...moved && { exitId: due.exitId }, reasons });
     if (!delivery) {
       await firstMessages?.record({ ownerId, at, timeZone });
       return;
@@ -1722,7 +1203,7 @@ function createFlowTimers(input) {
     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: ${errorText5(error)}`));
+        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?.();
       try {
@@ -1731,7 +1212,7 @@ function createFlowTimers(input) {
         clearInterval(heartbeat);
       }
     } 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: ${errorText5(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)}`);
     }
   }
   async function tickOnce() {
@@ -1753,7 +1234,7 @@ function createFlowTimers(input) {
     start() {
       if (interval) return;
       interval = setInterval(() => {
-        tick().catch((error) => logError(`[\u0441\u0446\u0435\u043D\u0430\u0440\u0438\u0439] \u043E\u0431\u0445\u043E\u0434 \u0442\u0430\u0439\u043C\u0435\u0440\u043E\u0432 \u0443\u043F\u0430\u043B: ${errorText5(error)}`));
+        tick().catch((error) => logError(`[\u0441\u0446\u0435\u043D\u0430\u0440\u0438\u0439] \u043E\u0431\u0445\u043E\u0434 \u0442\u0430\u0439\u043C\u0435\u0440\u043E\u0432 \u0443\u043F\u0430\u043B: ${errorText4(error)}`));
       }, tickMs);
       interval.unref?.();
     },
@@ -1764,7 +1245,15 @@ function createFlowTimers(input) {
       });
     },
     tick,
-    reschedule
+    reschedule,
+    watch(chatId, onFired) {
+      const listeners = watchers.get(chatId) ?? /* @__PURE__ */ new Set();
+      watchers.set(chatId, listeners.add(onFired));
+      return () => {
+        listeners.delete(onFired);
+        if (listeners.size === 0) watchers.delete(chatId);
+      };
+    }
   };
 }
 
@@ -2367,7 +1856,7 @@ 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 errorText6 = (error) => error instanceof Error ? error.message : String(error);
+var errorText5 = (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(",")}]`;
@@ -2442,7 +1931,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: ${errorText6(error)}`);
+        logError(`[\u0441\u0446\u0435\u043D\u0430\u0440\u0438\u0439] ${name} \u043D\u0435\u0434\u043E\u0441\u0442\u0443\u043F\u0435\u043D: ${errorText5(error)}`);
         return null;
       }
     });
@@ -2507,7 +1996,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: ${errorText6(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: ${errorText5(error)}`)).finally(() => background.delete(tracked));
     background.add(tracked);
   }
   const known = /* @__PURE__ */ new Map();
@@ -2679,7 +2168,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: ${errorText6(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)}`);
         return {};
       }
     },
@@ -2688,7 +2177,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: ${errorText6(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)}`);
       }
       const { schedule } = pinned.flow;
       const timeZone = schedule ? await timeZones.of(ownerId, chatId) : null;
@@ -2721,7 +2210,7 @@ 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: ${errorText6(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)}`);
     }
   }
   async function rescheduleUndelivered({ ownerId, chatId, at }) {
@@ -2745,7 +2234,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: ${errorText6(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)}`);
     }
   }
   async function deliverFirstText(ownerId, chatId, messageId, condition, text) {
@@ -2867,7 +2356,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: ${errorText6(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: ${errorText5(error)}`);
     }
   }
   async function readRun(ownerId, chatId) {
@@ -2901,6 +2390,8 @@ function buildAgentFlow(options, modules = {}) {
         ...chat,
         // Место в сценарии — служебное: посетитель его не видит, редактор и тестовый чат читают `readRun`.
         privateStateKeys: [.../* @__PURE__ */ new Set([...chat.privateStateKeys ?? [], FLOW_STATE_KEY])],
+        // Строки «Агент написал первым» на экране (право `appNotices`): только проекция, сырые данные пометок не уходят.
+        appNoticeViews: { ...chat.appNoticeViews, ...FLOW_APP_NOTICE_VIEWS },
         beforeTurn: async (input) => {
           const own = await chat.beforeTurn?.(input);
           return own ?? gate(input);
@@ -2969,7 +2460,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: ${errorText6(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);
               })();
@@ -3289,6 +2780,7 @@ export {
   FLOW_TIMER_SPANS,
   FLOW_TIMER_UNITS,
   FLOW_TIME_ZONE_TOOL,
+  FlowTestClockError,
   RETURN_TARGET,
   activeExits,
   agentFlowSchema,
@@ -3333,6 +2825,7 @@ export {
   noteRejectedClaim,
   noteSideQuestion,
   openSideTasks,
+  parseDuration,
   parseFlow,
   placeOfPath,
   resolveFirstMessages,