chatwoot-router 0.1.0 → 0.3.0

package/lib/packages/chatwoot-router/src/index.js

@@ -2,6 +2,118 @@
 import { Hono } from "hono";
 import { bodyLimit } from "hono/body-limit";
 
+// ../../shared/deadline.ts
+async function within(pending, signal) {
+  let abort;
+  try {
+    return await Promise.race([
+      pending,
+      new Promise((_resolve, reject) => {
+        abort = () => reject(signal.reason);
+        if (signal.aborted) abort();
+        else signal.addEventListener("abort", abort, { once: true });
+      })
+    ]);
+  } finally {
+    if (abort) signal.removeEventListener("abort", abort);
+  }
+}
+var JobDeadlineError = class extends Error {
+  requestStarted;
+  constructor(requestStarted = false) {
+    super("Job time slice is used up");
+    this.name = "JobDeadlineError";
+    this.requestStarted = requestStarted;
+  }
+};
+
+// ../../shared/budget.ts
+var BudgetExhaustedError = class extends Error {
+  constructor() {
+    super("Subrequest budget for this invocation is used up");
+    this.name = "BudgetExhaustedError";
+  }
+};
+var METADATA_TIMEOUT_MS = 1500;
+var JOB_SLICE_MS = 1e4;
+var Budget = class {
+  constructor(limit, fetchImpl = (request) => fetch(request)) {
+    this.limit = limit;
+    this.fetchImpl = fetchImpl;
+  }
+  limit;
+  fetchImpl;
+  used = 0;
+  slice;
+  sliceEnds = Number.POSITIVE_INFINITY;
+  get remaining() {
+    return this.limit - this.used;
+  }
+  startSlice(ms = JOB_SLICE_MS) {
+    this.sliceEnds = Date.now() + ms;
+    this.slice = AbortSignal.timeout(ms);
+  }
+  requireTime(ms) {
+    this.checkpoint();
+    if (Date.now() + ms > this.sliceEnds) throw new JobDeadlineError();
+  }
+  checkpoint() {
+    if (this.slice?.aborted) throw new JobDeadlineError();
+  }
+  consume() {
+    this.checkpoint();
+    if (this.used >= this.limit) throw new BudgetExhaustedError();
+    this.used += 1;
+  }
+  require(requests) {
+    this.checkpoint();
+    if (this.remaining < requests) throw new BudgetExhaustedError();
+  }
+  controlSignal(ms) {
+    return AbortSignal.any([AbortSignal.timeout(ms), ...this.slice ? [this.slice] : []]);
+  }
+  fetchWith(timeoutMs) {
+    return (request) => this.request(request, timeoutMs);
+  }
+  fetch = (request) => this.request(request, METADATA_TIMEOUT_MS);
+  async request(request, timeoutMs) {
+    this.consume();
+    const operation = AbortSignal.timeout(timeoutMs);
+    const signal = AbortSignal.any([request.signal, operation, ...this.slice ? [this.slice] : []]);
+    try {
+      const response = await within(this.fetchImpl(new Request(request, { signal })), signal);
+      if (!response.body) return response;
+      const reader = response.body.getReader();
+      const slice = this.slice;
+      const body = new ReadableStream({
+        async pull(controller) {
+          try {
+            const { done, value } = await within(reader.read(), signal);
+            if (done) controller.close();
+            else controller.enqueue(value);
+          } catch (error) {
+            controller.error(slice?.aborted ? new JobDeadlineError(true) : error);
+            void reader.cancel().catch(() => {
+            });
+          }
+        },
+        cancel: (reason) => {
+          void reader.cancel(reason).catch(() => {
+          });
+        }
+      });
+      return new Response(body, {
+        status: response.status,
+        statusText: response.statusText,
+        headers: response.headers
+      });
+    } catch (error) {
+      if (this.slice?.aborted) throw new JobDeadlineError(true);
+      throw error;
+    }
+  }
+};
+
 // ../../shared/chatwoot/signature.ts
 var TIMESTAMP_TOLERANCE_SECONDS = 300;
 var encoder = new TextEncoder();
@@ -65,37 +177,16 @@ function errorFields(error) {
   return error instanceof Error ? { error: error.name, detail: error.message } : { error: String(error) };
 }
 
-// src/router.ts
-import { DurableObject } from "cloudflare:workers";
+// src/coordinator.ts
+import { DurableObject as DurableObject2 } from "cloudflare:workers";
 import { z as z7 } from "zod";
 
-// ../../shared/budget.ts
-var BudgetExhaustedError = class extends Error {
-  constructor() {
-    super("Subrequest budget for this invocation is used up");
-    this.name = "BudgetExhaustedError";
-  }
-};
-var REQUEST_TIMEOUT_MS = 6e4;
-var Budget = class {
-  constructor(limit, fetchImpl = (request) => fetch(request), timeoutMs = REQUEST_TIMEOUT_MS) {
-    this.limit = limit;
-    this.fetchImpl = fetchImpl;
-    this.timeoutMs = timeoutMs;
-  }
-  limit;
-  fetchImpl;
-  timeoutMs;
-  used = 0;
-  get remaining() {
-    return this.limit - this.used;
-  }
-  fetch = (request) => {
-    if (this.used >= this.limit) return Promise.reject(new BudgetExhaustedError());
-    this.used += 1;
-    return this.fetchImpl(new Request(request, { signal: AbortSignal.timeout(this.timeoutMs) }));
-  };
-};
+// ../../shared/alarm.ts
+async function scheduleAlarm(state, next) {
+  if (next === void 0) return;
+  const current = await state.storage.getAlarm();
+  if (current === null || current > next) await state.storage.setAlarm(Math.max(Date.now(), next));
+}
 
 // ../../shared/chatwoot/api.ts
 import createClient from "openapi-fetch";
@@ -103,11 +194,13 @@ import { z as z2 } from "zod";
 var ChatwootError = class extends Error {
   status;
   conversationMissing;
-  constructor(status, operation, conversationMissing = false) {
+  retryAfterMs;
+  constructor(status, operation, conversationMissing = false, retryAfterMs) {
     super(`Chatwoot ${operation} failed with HTTP ${status}`);
     this.name = "ChatwootError";
     this.status = status;
     this.conversationMissing = conversationMissing;
+    this.retryAfterMs = retryAfterMs;
   }
 };
 var text = z2.string().nullish();
@@ -136,6 +229,7 @@ var emailSchema = z2.object({
 });
 var messageSchema = z2.object({
   id: z2.number(),
+  conversation_id: z2.number().optional(),
   content: text,
   message_type: z2.number(),
   content_type: text,
@@ -148,6 +242,7 @@ var messageSchema = z2.object({
     email: emailSchema.nullish(),
     deleted: z2.boolean().nullish(),
     external_error: text,
+    activity: z2.object({ type: text, status: text }).nullish(),
     submitted_values: z2.unknown().optional(),
     submitted_email: z2.unknown().optional(),
     items: z2.unknown().optional()
@@ -157,14 +252,33 @@ var messageSchema = z2.object({
   attachments: z2.array(attachmentSchema).nullish()
 });
 var messageListSchema = z2.object({ payload: z2.array(messageSchema) });
-var MESSAGE_PAGE_SIZE = 100;
-function chatwootClient(baseUrl, token, fetch2) {
+var MESSAGE_HISTORY_PAGE_SIZE = 20;
+var inboxBotSchema = z2.object({
+  agent_bot: z2.object({ id: z2.number().int().positive().optional(), account_id: z2.number().int().positive().nullish() }).nullable()
+});
+function chatwootClient(baseUrl, token, fetch2, limits) {
   const client = createClient({
     baseUrl: baseUrl.replace(/\/+$/, ""),
     headers: { api_access_token: token },
     // A redirect is an error, never followed: it could carry the token to another host, and each
     // hop would be a subrequest the budget does not count. Configure Chatwoot's final URL.
-    fetch: (request) => fetch2(new Request(request, { redirect: "manual" }))
+    fetch: async (request) => {
+      const account = /\/accounts\/(\d+)\//.exec(new URL(request.url).pathname)?.[1] ?? "profile";
+      const key = `chatwoot:limit:${baseUrl}:${account}`;
+      const wait = Number(limits?.get(key) ?? 0) - Date.now();
+      if (wait > 0) throw new ChatwootError(429, "rate limited", false, wait);
+      const response = await fetch2(new Request(request, { redirect: "manual" }));
+      if (response.status === 429) {
+        const header = response.headers.get("retry-after");
+        const seconds = Number(header);
+        const delay = header === null ? 5e3 : Number.isFinite(seconds) ? seconds * 1e3 : Date.parse(header) - Date.now();
+        const retryAfterMs = Number.isFinite(delay) ? Math.max(1, delay) : 5e3;
+        limits?.set(key, String(Date.now() + retryAfterMs), retryAfterMs);
+        await response.body?.cancel();
+        throw new ChatwootError(429, "rate limited", false, retryAfterMs);
+      }
+      return response;
+    }
   });
   async function data(operation, pending) {
     const { data: data2, response } = await pending;
@@ -174,7 +288,7 @@ function chatwootClient(baseUrl, token, fetch2) {
   async function dataUnlessNotFound(operation, pending) {
     const { data: data2, response } = await pending;
     if (notFound(response)) {
-      log.info("conversation deleted", { operation });
+      log.info("Chatwoot resource deleted", { operation });
       return void 0;
     }
     if (!response.ok || data2 === void 0) throw new ChatwootError(response.status, operation);
@@ -193,15 +307,6 @@ function chatwootClient(baseUrl, token, fetch2) {
     );
     return list && messageListSchema.parse(list).payload.toSorted((a, b) => a.id - b.id);
   }
-  function setCustomAttributes(accountId2, conversationId, attributes) {
-    return ensureOk(
-      "set custom attribute",
-      client.POST("/api/v1/accounts/{account_id}/conversations/{conversation_id}/custom_attributes", {
-        params: { path: { account_id: accountId2, conversation_id: conversationId } },
-        body: { custom_attributes: attributes, merge: true }
-      })
-    );
-  }
   return {
     /** The conversation, or undefined when it does not exist (it was deleted). */
     getConversation(accountId2, conversationId) {
@@ -227,6 +332,21 @@ function chatwootClient(baseUrl, token, fetch2) {
       const messages = await listMessages(accountId2, conversationId, { after: messageId - 1, before: messageId + 1 });
       return messages?.find((message) => message.id === messageId);
     },
+    async inboxBot(accountId2, inboxId) {
+      const value = await dataUnlessNotFound(
+        "get inbox agent bot",
+        client.GET("/api/v1/accounts/{account_id}/inboxes/{id}/agent_bot", {
+          params: { path: { account_id: accountId2, id: inboxId } }
+        })
+      );
+      if (value === void 0) return void 0;
+      const parsed = inboxBotSchema.safeParse(value);
+      if (!parsed.success) throw new Error("Chatwoot returned an invalid inbox bot");
+      const bot = parsed.data.agent_bot;
+      if (bot?.id === void 0) return void 0;
+      if (bot.account_id !== accountId2) throw new Error("Chatwoot inbox bot does not belong to the account");
+      return { id: bot.id };
+    },
     async inboxName(accountId2, inboxId) {
       const inbox = await data(
         "get inbox",
@@ -295,12 +415,13 @@ function chatwootClient(baseUrl, token, fetch2) {
         false
       );
     },
-    assign(accountId2, conversationId, assigneeId) {
+    assign(accountId2, conversationId, assigneeId, assigneeType = "User") {
+      const body = { assignee_id: assigneeId, assignee_type: assigneeType };
       return ensureOk(
         "assign conversation",
         client.POST("/api/v1/accounts/{account_id}/conversations/{conversation_id}/assignments", {
           params: { path: { account_id: accountId2, conversation_id: conversationId } },
-          body: { assignee_id: assigneeId }
+          body
         })
       );
     },
@@ -346,13 +467,21 @@ function chatwootClient(baseUrl, token, fetch2) {
         })
       );
     },
-    setCustomAttributes,
+    setCustomAttributes(accountId2, conversationId, attributes) {
+      return ensureOk(
+        "set custom attribute",
+        client.POST("/api/v1/accounts/{account_id}/conversations/{conversation_id}/custom_attributes", {
+          params: { path: { account_id: accountId2, conversation_id: conversationId } },
+          body: { custom_attributes: attributes, merge: true }
+        })
+      );
+    },
     /**
      * Sends an outgoing message (or private note). With files it is sent as the spec's
      * multipart/form-data body; the generated type renders its `attachments[]` binaries as
      * strings, so the serializer appends the files itself.
      */
-    createMessage(accountId2, conversationId, message) {
+    async createMessage(accountId2, conversationId, message) {
       const fields = {
         content: message.content,
         message_type: "outgoing",
@@ -368,23 +497,30 @@ function chatwootClient(baseUrl, token, fetch2) {
         for (const file of message.files) form.append("attachments[]", file.blob, file.filename);
         return form;
       };
-      return ensureOk(
-        "create message",
-        client.POST("/api/v1/accounts/{account_id}/conversations/{conversation_id}/messages", {
+      const { data: data2, response } = await client.POST(
+        "/api/v1/accounts/{account_id}/conversations/{conversation_id}/messages",
+        {
           params: { path: { account_id: accountId2, conversation_id: conversationId } },
           body: fields,
           ...message.files.length === 0 ? {} : { bodySerializer: () => multipart(fields) }
-        })
+        }
       );
+      if (!response.ok) throw new ChatwootError(response.status, "create message", notFound(response));
+      const parsed = messageSchema.safeParse(data2);
+      return parsed.success ? parsed.data : void 0;
     }
   };
 }
 function notFound(response) {
   return response.status === 404 && (response.headers.get("content-type")?.includes("application/json") ?? false);
 }
+function personAssignee(conversation) {
+  const type = conversation.meta?.assignee_type;
+  return type == null || type === "User" ? conversation.meta?.assignee : void 0;
+}
 function toRelayConversation(conversationId, conversation) {
   const meta = conversation.meta;
-  const assignee = meta?.assignee;
+  const assignee = personAssignee(conversation);
   return {
     id: conversationId,
     status: conversation.status,
@@ -399,6 +535,7 @@ function toRelayConversation(conversationId, conversation) {
       avatarUrl: meta?.sender?.thumbnail ?? null
     },
     assignee: assignee ? { id: assignee.id, name: assignee.name } : null,
+    assigneeType: meta?.assignee_type ?? null,
     customAttributes: conversation.custom_attributes ?? {}
   };
 }
@@ -422,12 +559,17 @@ function retryDelay(attempts) {
   return Math.min(5e3 * 2 ** attempts, 30 * 60 * 1e3);
 }
 var QueueStore = class {
-  constructor(sql, now = Date.now) {
+  constructor(sql, now = Date.now, atomic = (write2) => write2()) {
     this.sql = sql;
     this.now = now;
+    this.atomic = atomic;
   }
   sql;
   now;
+  atomic;
+  transaction(write2) {
+    return this.atomic(write2);
+  }
   migrate() {
     this.sql.exec(`CREATE TABLE IF NOT EXISTS jobs (
       key TEXT PRIMARY KEY, priority INTEGER NOT NULL, payload TEXT NOT NULL,
@@ -436,6 +578,10 @@ var QueueStore = class {
     );
     CREATE INDEX IF NOT EXISTS jobs_due ON jobs (not_before);
     CREATE TABLE IF NOT EXISTS cache (key TEXT PRIMARY KEY, value TEXT NOT NULL, expires_at INTEGER);`);
+    const columns = this.sql.exec("PRAGMA table_info(jobs)").toArray();
+    if (!columns.some((column) => column.name === "suspended")) {
+      this.sql.exec("ALTER TABLE jobs ADD COLUMN suspended INTEGER NOT NULL DEFAULT 0");
+    }
   }
   // Cache
   get(key) {
@@ -454,14 +600,6 @@ var QueueStore = class {
   delete(key) {
     this.sql.exec("DELETE FROM cache WHERE key = ?", key);
   }
-  list(start, end) {
-    return this.sql.exec(
-      "SELECT value FROM cache WHERE key >= ? AND key < ? AND (expires_at IS NULL OR expires_at > ?) ORDER BY key",
-      start,
-      end,
-      this.now()
-    ).toArray().map((row) => row.value);
-  }
   // Jobs
   /**
    * Adds a job, or marks an existing one as needing another run (its version changes). A job
@@ -470,7 +608,7 @@ var QueueStore = class {
   enqueue(key, priority, payload, notBefore = this.now()) {
     this.sql.exec(
       `INSERT INTO jobs (key, priority, payload, not_before, created_at) VALUES (?, ?, ?, ?, ?)
-       ON CONFLICT (key) DO UPDATE SET version = version + 1, payload = excluded.payload,
+       ON CONFLICT (key) DO UPDATE SET version = version + 1, payload = excluded.payload, suspended = 0,
          not_before = CASE WHEN attempts > 0 THEN not_before ELSE MIN(not_before, excluded.not_before) END`,
       key,
       priority,
@@ -480,18 +618,24 @@ var QueueStore = class {
     );
   }
   nextDueJob() {
-    const row = this.sql.exec(
-      `SELECT key, payload, version, attempts, created_at FROM jobs WHERE not_before <= ?
-         ORDER BY priority, not_before, created_at LIMIT 1`,
-      this.now()
-    ).toArray()[0];
-    if (!row) return void 0;
-    const { created_at: createdAt, ...job } = row;
-    return { ...job, createdAt };
+    return this.nextDueJobs(1)[0];
+  }
+  /** A bounded due batch; independent scan and delivery work can select their own keys. */
+  nextDueJobs(limit, prefix = "") {
+    return this.sql.exec(
+      `SELECT key, payload, version, attempts, created_at AS createdAt FROM jobs
+         WHERE suspended != 2 AND not_before <= ? AND substr(key, 1, ?) = ?
+         ORDER BY MAX(0, priority - CAST((? - created_at) / 30000 AS INTEGER)), not_before, created_at LIMIT ?`,
+      this.now(),
+      prefix.length,
+      prefix,
+      this.now(),
+      limit
+    ).toArray();
   }
   /** Earliest due time. */
   nextWakeup() {
-    const row = this.sql.exec("SELECT MIN(not_before) AS at FROM jobs").toArray()[0];
+    const row = this.sql.exec("SELECT MIN(not_before) AS at FROM jobs WHERE suspended != 2").toArray()[0];
     return row?.at ?? void 0;
   }
   /** Removes a finished job unless it was enqueued again while running. */
@@ -516,73 +660,170 @@ var QueueStore = class {
   deferJob(job, delayMs = 0) {
     this.sql.exec("UPDATE jobs SET not_before = ? WHERE key = ?", this.now() + delayMs, job.key);
   }
+  /** One short re-read for a racing status webhook, then wait for an event or a sweep. */
+  holdJob(job) {
+    this.sql.exec(
+      `UPDATE jobs SET suspended = CASE WHEN suspended = 0 THEN 1 ELSE 2 END,
+       not_before = ?, attempts = 0 WHERE key = ? AND version = ?`,
+      this.now() + 1e3,
+      job.key,
+      job.version
+    );
+  }
+  /** Suspended conversation jobs need reconciliation even outside the ordinary activity window. */
+  wakeHeldJobs() {
+    this.sql.exec("UPDATE jobs SET suspended = 0, not_before = ? WHERE suspended = 2", this.now());
+  }
   prune() {
     this.sql.exec("DELETE FROM cache WHERE expires_at IS NOT NULL AND expires_at <= ?", this.now());
   }
 };
 
-// ../../shared/sweep.ts
-import { z as z3 } from "zod";
-var passSchema = z3.object({ cutoff: z3.number(), page: z3.number().int().positive(), startedAt: z3.number() });
-var PASS_TTL_MS = 24 * 60 * 60 * 1e3;
-function readSweepPass(store, accountId2, reconcile) {
-  const parsed = passSchema.safeParse(parseJson(store.get(`sweep:${accountId2}:pass`)));
-  if (parsed.success) return parsed.data;
-  const now = Date.now();
-  const last = Number(store.get(`sweep:${accountId2}:last`) ?? 0);
-  const { lookbackSeconds, maxCatchUpSeconds } = reconcile;
-  const sinceLast = last > 0 ? (now - last) / 1e3 + 60 : lookbackSeconds;
-  const window = Math.min(Math.max(sinceLast, lookbackSeconds), maxCatchUpSeconds);
-  return { cutoff: now / 1e3 - window, page: 1, startedAt: now };
-}
-function saveSweepPass(store, accountId2, pass, nextPage) {
-  const key = `sweep:${accountId2}:pass`;
-  if (nextPage === void 0) {
-    store.set(`sweep:${accountId2}:last`, String(pass.startedAt));
-    store.delete(key);
-  } else {
-    store.set(key, JSON.stringify({ ...pass, page: nextPage }), PASS_TTL_MS);
-  }
-}
+// src/router.ts
+import { DurableObject } from "cloudflare:workers";
+import { z as z6 } from "zod";
 
 // src/routing.ts
 import ipRegex from "ip-regex";
-import { z as z5 } from "zod";
+import { z as z4 } from "zod";
 
-// ../../shared/attributes.ts
-var ROUTING_ATTRIBUTES = {
-  seen: "routing_seen",
-  handled: "routing_handled",
-  kind: "routing_kind"
-};
-function messageWatermark(value) {
-  const number = typeof value === "string" ? Number(value) : value;
-  return typeof number === "number" && Number.isSafeInteger(number) && number >= 0 ? number : 0;
+// ../../shared/concurrent.ts
+async function parallel(...reads) {
+  await Promise.allSettled(reads);
+  return Promise.all(reads);
 }
 
-// src/effects.ts
-import { z as z4 } from "zod";
-var effectSchema = z4.object({
-  inputId: z4.number().int().min(0),
-  kind: z4.string().nullable(),
-  handled: z4.number().int().min(0)
+// src/reply.ts
+function confirmedReply(message, botId) {
+  return message !== void 0 && Number.isSafeInteger(message.id) && message.id > 0 && message.message_type === 1 && message.private === false && message.sender?.type === "agent_bot" && message.sender.id === botId && message.status !== "failed" && !message.content_attributes?.deleted;
+}
+async function replyHistory(chatwoot, accountId2, conversationId, botId, freshPages = []) {
+  let before;
+  for (let page = 0; page < 5; page += 1) {
+    const messages = freshPages[page] ?? await chatwoot.listMessages(accountId2, conversationId, before === void 0 ? {} : { before });
+    for (const message of messages) {
+      if (confirmedReply(message, botId)) return "found";
+      if (message.message_type !== 1 || message.private === true) continue;
+      if (message.sender?.type == null || message.sender.type === "agent_bot" && (message.sender.id == null || message.sender.id === botId))
+        return "unknown";
+    }
+    if (messages.length < MESSAGE_HISTORY_PAGE_SIZE) return "complete-none";
+    const next = messages[0]?.id;
+    if (next === void 0 || before !== void 0 && next >= before) return "unknown";
+    before = next;
+  }
+  return "unknown";
+}
+
+// src/turn.ts
+import { z as z3 } from "zod";
+var guardSchema = z3.object({
+  boundary: z3.number().optional(),
+  claimed: z3.boolean().optional(),
+  pending: z3.boolean().optional(),
+  transitionAt: z3.number().optional(),
+  expected: z3.object({ status: z3.string(), at: z3.number().optional(), after: z3.number().optional() }).optional(),
+  handoff: z3.boolean().default(false),
+  failures: z3.number().int().min(0).default(0)
 });
-async function actOnce(ctx, key, effect, record, act) {
-  if (ctx.store.get(key) !== void 0) return;
-  if (record === "before") ctx.store.set(key, JSON.stringify({ ...effect, handled: 0 }));
-  await act();
-  ctx.store.set(key, JSON.stringify(effect));
+function readGuard(store, accountId2, conversationId) {
+  const parsed = guardSchema.safeParse(parseJson(store.get(`turn:${accountId2}:${conversationId}`)));
+  return parsed.success ? parsed.data : { handoff: false, failures: 0 };
 }
-function readEffects(store, accountId2, conversationId) {
-  return [
-    store.get(`reply:${accountId2}:${conversationId}`),
-    ...["assign", "labels", "status"].flatMap(
-      (effect) => store.list(`${effect}:${accountId2}:${conversationId}:`, `${effect}:${accountId2}:${conversationId};`)
-    )
-  ].flatMap((value) => {
-    const parsed = effectSchema.safeParse(parseJson(value));
-    return parsed.success ? [parsed.data] : [];
-  }).sort((left, right) => left.inputId - right.inputId);
+function saveGuard(store, accountId2, conversationId, guard) {
+  store.set(`turn:${accountId2}:${conversationId}`, JSON.stringify(guard));
+}
+function expectActivity(store, accountId2, conversationId, transition) {
+  const guard = readGuard(store, accountId2, conversationId);
+  if (transition.at !== void 0 && transition.at <= (guard.transitionAt ?? 0)) return;
+  if (transition.at === void 0 && guard.expected?.status === transition.status) return;
+  const claimed = guard.claimed ?? guard.transitionAt !== void 0;
+  const after = transition.at === void 0 || claimed ? guard.boundary ?? 0 : 0;
+  saveGuard(store, accountId2, conversationId, {
+    ...guard,
+    // A first webhook must not relax a newer activity requirement already observed locally.
+    expected: { ...transition, after: Math.max(guard.expected?.after ?? 0, after) },
+    transitionAt: transition.at ?? guard.transitionAt,
+    handoff: false,
+    failures: 0
+  });
+}
+function observeStatus(store, accountId2, conversationId, status) {
+  const guard = readGuard(store, accountId2, conversationId);
+  const pending = status === "pending";
+  if (guard.pending && !pending) expectActivity(store, accountId2, conversationId, { status });
+  if (guard.pending !== pending) {
+    saveGuard(store, accountId2, conversationId, { ...readGuard(store, accountId2, conversationId), pending });
+  }
+}
+function requestHandoff(store, accountId2, conversationId) {
+  saveGuard(store, accountId2, conversationId, { ...readGuard(store, accountId2, conversationId), handoff: true });
+}
+function recordFailure(store, accountId2, conversationId) {
+  const guard = readGuard(store, accountId2, conversationId);
+  guard.failures += 1;
+  if (guard.failures >= 3) guard.handoff = true;
+  saveGuard(store, accountId2, conversationId, guard);
+  return guard.failures;
+}
+function clearFailures(store, accountId2, conversationId) {
+  const guard = readGuard(store, accountId2, conversationId);
+  if (guard.failures) saveGuard(store, accountId2, conversationId, { ...guard, failures: 0 });
+}
+var ActivityPendingError = class extends Error {
+  constructor() {
+    super("Chatwoot status activity is not available yet");
+    this.name = "ActivityPendingError";
+  }
+};
+async function readTurn(chatwoot, store, accountId2, conversationId) {
+  const messages = [];
+  const pages = [];
+  let before;
+  let boundary;
+  let complete = false;
+  let deleted = false;
+  for (let page = 0; page < 5; page += 1) {
+    const batch = await chatwoot.listMessages(accountId2, conversationId, before === void 0 ? {} : { before });
+    pages.push(batch);
+    for (const message of batch.toReversed()) {
+      if (message.message_type === 2 && message.content_attributes?.deleted) {
+        deleted = true;
+        break;
+      }
+      if (message.message_type === 2 && message.content_attributes?.activity?.type === "conversation_status_changed") {
+        boundary = message;
+        break;
+      }
+      messages.push(message);
+    }
+    complete = boundary !== void 0 || batch.length < MESSAGE_HISTORY_PAGE_SIZE;
+    if (complete || deleted) break;
+    const next = batch[0]?.id;
+    if (next === void 0 || before !== void 0 && next >= before) break;
+    before = next;
+  }
+  const guard = readGuard(store, accountId2, conversationId);
+  const missing = guard.boundary !== void 0 && (boundary?.id ?? 0) < guard.boundary;
+  const expected = guard.expected;
+  const activity = boundary?.content_attributes?.activity;
+  const late = expected && (!boundary || boundary.id <= (expected.after ?? 0) || expected.at !== void 0 && (boundary.created_at ?? 0) < Math.floor(expected.at) || activity?.status !== expected.status);
+  if (late && !guard.handoff && !deleted && !missing) throw new ActivityPendingError();
+  if (boundary && boundary.id !== guard.boundary && guard.boundary !== void 0 && !missing && !late) {
+    guard.handoff = false;
+    guard.failures = 0;
+  }
+  if (!missing && complete) {
+    if (guard.boundary !== (boundary?.id ?? 0)) guard.claimed = false;
+    guard.boundary = boundary?.id ?? 0;
+  }
+  if (expected && !late) {
+    guard.claimed = expected.at !== void 0;
+    delete guard.expected;
+  }
+  if (deleted || missing || !complete) guard.handoff = true;
+  saveGuard(store, accountId2, conversationId, guard);
+  return { pages, messages: messages.toReversed(), boundary: boundary?.id ?? 0, handoff: guard.handoff };
 }
 
 // src/routing.ts
@@ -594,7 +835,6 @@ var REQUEST_CRITERIA = {
 };
 var NO_KIND = "none";
 var NO_KIND_CRITERION = "None of the other kinds.";
-var JEV_URL = "https://api.typesafe.ai/v1/systemone";
 var MAX_MESSAGES = 3;
 var MAX_TEXT = 1600;
 var REDACTIONS = [
@@ -619,23 +859,23 @@ var REDACTIONS = [
   /(?<!\w)@[A-Za-z0-9_.-]{2,}/g
   // handles
 ];
-var decisionSchema = z5.object({
-  owner: z5.string().nullable(),
-  ownerConfidence: z5.number(),
-  topic: z5.string().nullable(),
-  topicConfidence: z5.number(),
-  kind: z5.string().nullable().default(null),
-  kindConfidence: z5.number().default(0),
-  /** Jev is confident the customer asked for nothing yet (asked with `snoozeUnclear` only). */
-  noRequest: z5.boolean().default(false)
+var decisionSchema = z4.object({
+  owner: z4.string().nullable(),
+  ownerConfidence: z4.number(),
+  topic: z4.string().nullable(),
+  topicConfidence: z4.number(),
+  kind: z4.string().nullable().default(null),
+  kindConfidence: z4.number().default(0),
+  /** Jev is confident the customer asked for nothing yet. */
+  noRequest: z4.boolean().default(false)
 });
-var jevResponseSchema = z5.object({
-  answers: z5.record(
-    z5.string(),
-    z5.object({
-      choice: z5.string(),
-      probabilities: z5.record(z5.string(), z5.number()).optional(),
-      confidence: z5.number().optional()
+var jevResponseSchema = z4.object({
+  answers: z4.record(
+    z4.string(),
+    z4.object({
+      choice: z4.string(),
+      probabilities: z4.record(z4.string(), z4.number()).optional(),
+      confidence: z4.number().optional()
     })
   )
 });
@@ -652,143 +892,171 @@ async function routeConversation(ctx, accountId2, conversationId) {
   const { settings, store, chatwoot } = ctx;
   const routing = settings.config.routing;
   const owners = routing.accounts[String(accountId2)];
-  if (!owners) return;
+  const token = settings.secrets.CHATWOOT_AGENT_BOT_TOKENS[String(accountId2)];
+  if (!owners || !token) return;
+  const bot = chatwootClient(settings.config.chatwoot.baseUrl, token, ctx.fetch);
   const kinds = routing.kinds?.[String(accountId2)] ?? {};
-  const raw = await chatwoot.getConversation(accountId2, conversationId);
-  if (!raw) return;
-  const conversation = toRelayConversation(conversationId, raw);
-  const latest = await chatwoot.listMessages(accountId2, conversationId, { filter_internal_messages: true });
-  const identities = [conversation.contact?.name, conversation.contact?.email];
-  const inputs = await customerInputs(ctx, accountId2, conversationId, identities);
-  let seen = Math.max(inputs.seen, ...latest.filter(isCustomer).map((message) => message.id));
-  const key = inputs.ids.join(",");
-  const memoKey = `decision:${accountId2}:${conversationId}:${key}`;
-  const cached = inputs.ids.map(
-    (_, index) => readDecision(store.get(`decision:${accountId2}:${conversationId}:${inputs.ids.slice(0, index + 1).join(",")}`))
-  );
-  let decision = cached.at(-1);
-  const previous = cached.findLast((entry) => entry !== void 0);
-  const kindFor = (answer) => answer?.kind && answer.kindConfidence >= routing.minConfidence ? kinds[answer.kind] : void 0;
-  const assigneeFor = (answer) => answer?.owner && answer.ownerConfidence >= routing.minConfidence ? owners[answer.owner]?.assignee : void 0;
-  const eligible = (observed2, answer) => conversationId > (settings.config.startAfterConversationId[String(accountId2)] ?? 0) && !observed2.contact?.blocked && observed2.status === "open" && (!observed2.assignee || observed2.assignee.id === assigneeFor(answer));
-  let observed = raw;
-  if (inputs.ids.length > 0 && eligible(conversation, previous)) {
-    if (!decision) {
-      decision = await decide(ctx, owners, routing.kinds?.[String(accountId2)], inputs.text);
-      store.set(memoKey, JSON.stringify(decision));
+  const botId = routing.botIds[String(accountId2)];
+  const owns = (conversation) => conversation?.meta?.assignee_type === "AgentBot" && conversation.meta.assignee?.id === botId;
+  const release = async () => {
+    const latest = await chatwoot.getConversation(accountId2, conversationId);
+    if (latest?.status !== void 0 && latest.status !== "pending" && owns(latest)) {
+      await bot.unassign(accountId2, conversationId);
     }
-    const freshInputs = await customerInputs(ctx, accountId2, conversationId, identities);
-    if (freshInputs.ids.join(",") !== key) return "defer";
-    seen = Math.max(seen, freshInputs.seen);
-    const fresh = await chatwoot.getConversation(accountId2, conversationId);
-    if (!fresh) return;
-    observed = fresh;
-    const current = toRelayConversation(conversationId, fresh);
-    if (eligible(current, decision)) {
-      const kind = kindFor(decision);
-      const kindName = kind ? decision.kind : null;
-      const assignee = kind?.status ? void 0 : assigneeFor(decision);
-      const inputId = inputs.ids.at(-1) ?? 0;
-      if (assignee !== void 0) {
-        await actOnce(
-          ctx,
-          `assign:${accountId2}:${conversationId}:${key}`,
-          { inputId, kind: null, handled: 0 },
-          "after",
-          async () => {
-            if (!current.assignee) await chatwoot.assign(accountId2, conversationId, assignee);
-          }
-        );
-      }
-      const topic = !kind?.status && decision.topic !== null && Object.hasOwn(routing.topics ?? {}, decision.topic) && decision.topicConfidence >= routing.minConfidence && current.labels.every((label) => Object.hasOwn(kinds, label)) ? decision.topic : null;
-      const labels = [.../* @__PURE__ */ new Set([...current.labels, ...[topic, kindName].filter((label) => label !== null)])];
-      await actOnce(
-        ctx,
-        `labels:${accountId2}:${conversationId}:${key}`,
-        { inputId, kind: kindName, handled: 0 },
-        "after",
-        async () => {
-          if (labels.length !== current.labels.length) await chatwoot.setLabels(accountId2, conversationId, labels);
-        }
-      );
-      const replyKey = `reply:${accountId2}:${conversationId}`;
-      const botToken = settings.botToken(accountId2);
-      if (kind?.cannedResponse && botToken && store.get(replyKey) === void 0) {
-        const content = await chatwoot.cannedResponse(accountId2, kind.cannedResponse);
-        if (content === void 0) throw new Error("Chatwoot canned response is missing");
-        const bot = chatwootClient(settings.config.chatwoot.baseUrl, botToken, ctx.fetch);
-        await actOnce(
-          ctx,
-          replyKey,
-          { inputId, kind: kindName, handled: inputId },
-          "before",
-          () => bot.createMessage(accountId2, conversationId, { content, private: false, files: [] })
-        );
-      }
-      const snooze = !assignee && inputs.ids.length < MAX_MESSAGES && routing.snoozeUnclear && decision.noRequest;
-      const status = freshInputs.complete ? kind?.status ?? (snooze ? "snoozed" : void 0) : void 0;
-      if (status) {
-        await actOnce(
-          ctx,
-          `status:${accountId2}:${conversationId}:${key}`,
-          { inputId, kind: kindName, handled: kind?.status ? inputId : 0 },
-          "before",
-          () => chatwoot.setStatus(accountId2, conversationId, { status })
-        );
+  };
+  const snapshot = async (inboxId) => {
+    const raw = await chatwoot.getConversation(accountId2, conversationId);
+    if (!raw || raw.inbox_id === void 0 || inboxId !== void 0 && raw.inbox_id !== inboxId) return;
+    if (raw.status !== "pending") {
+      observeStatus(store, accountId2, conversationId, raw.status ?? "open");
+      if (raw.status !== void 0 && owns(raw)) await release();
+      return;
+    }
+    const conversation = toRelayConversation(conversationId, raw);
+    if (conversation.assignee) return;
+    if (raw.meta?.assignee && (raw.meta.assignee_type !== "AgentBot" || raw.meta.assignee.id !== botId)) return;
+    if ((await chatwoot.inboxBot(accountId2, raw.inbox_id))?.id !== botId) {
+      if (owns(raw)) {
+        const latest = await chatwoot.getConversation(accountId2, conversationId);
+        if (latest?.status === "pending" && latest.inbox_id === raw.inbox_id && owns(latest))
+          await bot.setStatus(accountId2, conversationId, { status: "open" });
       }
+      return;
     }
-  }
-  await syncAttributes(ctx, accountId2, conversationId, observed, seen);
-}
-async function syncAttributes(ctx, accountId2, conversationId, observed, seen) {
-  const current = observed.custom_attributes ?? {};
-  const names = ROUTING_ATTRIBUTES;
-  const key = `seen:${accountId2}:${conversationId}`;
-  const checkpoint = Math.max(messageWatermark(ctx.store.get(key)), seen, messageWatermark(current[names.seen]));
-  ctx.store.set(key, String(checkpoint));
-  const effects = readEffects(ctx.store, accountId2, conversationId);
-  const handled = Math.max(0, ...effects.map((effect) => effect.handled));
-  const kind = effects.findLast((effect) => effect.kind !== null)?.kind ?? null;
-  const attributes = {
-    [names.seen]: checkpoint,
-    ...handled > 0 ? { [names.handled]: Math.max(handled, messageWatermark(current[names.handled])) } : {},
-    ...kind === null ? {} : { [names.kind]: kind }
+    if (conversation.contact.blocked) return;
+    observeStatus(store, accountId2, conversationId, "pending");
+    return { raw, conversation };
   };
-  if (Object.entries(attributes).some(
-    ([name, value]) => (name === names.kind ? current[name] : messageWatermark(current[name])) !== value
-  ))
-    await ctx.chatwoot.setCustomAttributes(accountId2, conversationId, attributes);
-}
-function isCustomer(message) {
-  return message.message_type === 0 && !message.private;
-}
-async function customerInputs(ctx, accountId2, conversationId, identities) {
-  const ids = [];
-  const parts = [];
-  let after = 0;
-  let seen = 0;
-  let complete = false;
-  for (let page = 0; page < 3 && ids.length < MAX_MESSAGES; page += 1) {
-    const messages = await ctx.chatwoot.listMessages(accountId2, conversationId, {
-      after,
-      filter_internal_messages: true
-    });
-    for (const message of messages.filter(isCustomer)) {
-      seen = Math.max(seen, message.id);
+  const initial = await snapshot();
+  if (!initial) return;
+  const identities = [initial.conversation.contact.name, initial.conversation.contact.email];
+  const inputs = (messages) => {
+    const texts = messages.filter(isCustomer).flatMap((message) => {
       const text2 = sanitize(
         [message.content_attributes?.email?.subject ?? "", messageContent(message)].join("\n"),
         identities
       );
-      if (ids.length < MAX_MESSAGES && text2.replaceAll("[REDACTED]", "").trim()) {
-        ids.push(message.id);
-        parts.push(text2);
+      return text2.replaceAll("[REDACTED]", "").trim() ? [{ id: message.id, text: text2 }] : [];
+    }).slice(0, MAX_MESSAGES);
+    return {
+      key: texts.map((entry) => entry.id).join(","),
+      text: texts.map((entry) => entry.text).join(" ").slice(0, MAX_TEXT),
+      count: texts.length
+    };
+  };
+  const turn = await readTurn(chatwoot, store, accountId2, conversationId);
+  const input = inputs(turn.messages);
+  const requiresHandoff = (messages) => messages.some(
+    (message) => message.message_type === 1 && !message.private && (message.sender?.type === "user" && !message.content_attributes?.deleted || message.sender?.type === "agent_bot" && message.sender.id === botId && (message.status === "failed" || message.content_attributes?.deleted))
+  );
+  const fresh = async () => {
+    const current2 = await snapshot(initial.raw.inbox_id);
+    if (!current2) return;
+    const latest = await readTurn(chatwoot, store, accountId2, conversationId);
+    if (latest.boundary !== turn.boundary || inputs(latest.messages).key !== input.key || inputs(latest.messages).text !== input.text)
+      return "defer";
+    return { ...current2, pages: latest.pages, handoff: latest.handoff || requiresHandoff(latest.messages) };
+  };
+  const handoff = async (current2) => {
+    requestHandoff(store, accountId2, conversationId);
+    current2 ??= await fresh();
+    if (current2 === "defer") return "defer";
+    if (current2) await bot.setStatus(accountId2, conversationId, { status: "open" });
+    return void 0;
+  };
+  if (turn.handoff || requiresHandoff(turn.messages) || input.count === 0) return handoff();
+  const fingerprint = await crypto.subtle.digest(
+    "SHA-256",
+    new TextEncoder().encode(JSON.stringify({ text: input.text, routing }))
+  );
+  const hash = Array.from(new Uint8Array(fingerprint), (byte) => byte.toString(16).padStart(2, "0")).join("");
+  const memoKey = `decision:${accountId2}:${conversationId}:${input.key}:${hash}`;
+  const memo = decisionSchema.safeParse(parseJson(store.get(memoKey)));
+  let decision = memo.success ? memo.data : void 0;
+  if (!decision) {
+    decision = await decide(ctx, owners, routing.kinds?.[String(accountId2)], input.text);
+    store.set(memoKey, JSON.stringify(decision));
+  }
+  const kind = decision.kind && decision.kindConfidence >= routing.minConfidence ? kinds[decision.kind] : void 0;
+  const assignee = decision.owner && decision.ownerConfidence >= routing.minConfidence ? owners[decision.owner]?.assignee : void 0;
+  const replyKey = `reply:${accountId2}:${conversationId}`;
+  if (store.get(replyKey) === void 0 && turn.pages.some((page) => page.some((message) => confirmedReply(message, botId))))
+    store.set(replyKey, "observed");
+  const actionable = kind !== void 0 || !decision.noRequest || input.count >= MAX_MESSAGES;
+  const [content, agents] = await parallel(
+    kind?.cannedResponse && store.get(replyKey) === void 0 ? chatwoot.cannedResponse(accountId2, kind.cannedResponse) : Promise.resolve(void 0),
+    actionable && assignee !== void 0 && !kind?.status ? chatwoot.listAgents(accountId2) : Promise.resolve(void 0)
+  );
+  let current = await fresh();
+  if (current === "defer" || !current) return current;
+  if (current.handoff) return handoff(current);
+  if (!kind && decision.noRequest && input.count < MAX_MESSAGES) return;
+  const topic = !kind?.status && decision.topic !== null && Object.hasOwn(routing.topics ?? {}, decision.topic) && decision.topicConfidence >= routing.minConfidence && current.conversation.labels.every((label) => Object.hasOwn(kinds, label)) ? decision.topic : null;
+  const labels = [
+    .../* @__PURE__ */ new Set([
+      ...current.conversation.labels,
+      ...[topic, kind ? decision.kind : null].filter((label) => label !== null)
+    ])
+  ];
+  let changed = false;
+  if (labels.length !== current.conversation.labels.length) {
+    await bot.setLabels(accountId2, conversationId, labels);
+    changed = true;
+  }
+  if (kind?.cannedResponse) {
+    let history;
+    try {
+      if (changed) {
+        current = await fresh();
+        if (current === "defer" || !current) return current;
+        if (current.handoff) return handoff(current);
+        changed = false;
+      }
+      history = await replyHistory(chatwoot, accountId2, conversationId, botId, current.pages);
+    } catch (error) {
+      log.warn("reply history unavailable; handing off", { accountId: accountId2, conversationId, ...errorFields(error) });
+      return handoff();
+    }
+    if (history === "unknown" || history === "complete-none" && store.get(replyKey) !== void 0) return handoff();
+    if (history === "found" && store.get(replyKey) === void 0) store.set(replyKey, "observed");
+    if (history === "complete-none") {
+      if (!content?.trim()) return handoff();
+      current = await fresh();
+      if (current === "defer" || !current) return current;
+      if (current.handoff) return handoff(current);
+      store.set(replyKey, "attempted");
+      try {
+        const message = await bot.createMessage(accountId2, conversationId, { content, private: false, files: [] });
+        if (!confirmedReply(message, botId) || message?.conversation_id !== conversationId) return handoff();
+        changed = true;
+      } catch (error) {
+        log.warn("reply creation unconfirmed; handing off", { accountId: accountId2, conversationId, ...errorFields(error) });
+        return handoff();
       }
     }
-    complete = ids.length === MAX_MESSAGES || messages.length < MESSAGE_PAGE_SIZE;
-    if (complete) break;
-    after = messages.at(-1)?.id ?? after;
   }
-  return { ids, text: parts.join(" ").slice(0, MAX_TEXT), complete, seen };
+  if (assignee !== void 0 && !kind?.status) {
+    if (!agents?.some((agent) => agent.id === assignee)) return handoff();
+  }
+  if (changed) {
+    current = await fresh();
+    if (current === "defer" || !current) return current;
+    if (current.handoff) return handoff(current);
+  }
+  if (kind?.status) {
+    await bot.setStatus(accountId2, conversationId, { status: kind.status });
+    expectActivity(store, accountId2, conversationId, { status: kind.status });
+    await release();
+  } else if (assignee !== void 0 && current.raw.meta?.assignee_type === "AgentBot") {
+    await bot.assign(accountId2, conversationId, assignee);
+    expectActivity(store, accountId2, conversationId, { status: "open" });
+  } else {
+    return handoff(current);
+  }
+  return void 0;
+}
+function isCustomer(message) {
+  return message.message_type === 0 && !message.private && !message.content_attributes?.deleted && !message.content_attributes?.email?.auto_reply && (message.sender?.type == null || message.sender.type === "contact");
 }
 function sanitize(text2, identities) {
   let value = text2.normalize("NFKC");
@@ -803,7 +1071,6 @@ function sanitize(text2, identities) {
 async function decide(ctx, owners, kinds, text2) {
   const routing = ctx.settings.config.routing;
   const apiKey = ctx.settings.secrets.TYPESAFE_API_KEY;
-  if (!routing || !apiKey) throw new JevError("routing is not configured");
   const ownerCriteria = Object.fromEntries(
     Object.entries(owners).map(([route, owner2]) => [route, owner2.covers])
   );
@@ -822,13 +1089,11 @@ async function decide(ctx, owners, kinds, text2) {
       criteria: routing.topics
     };
   }
-  if (routing.snoozeUnclear) {
-    questions.request = {
-      type: "choice",
-      instructions: "Select whether the customer asks for anything in this support ticket, using only the ticket.",
-      criteria: REQUEST_CRITERIA
-    };
-  }
+  questions.request = {
+    type: "choice",
+    instructions: "Select whether the customer asks for anything in this support ticket, using only the ticket.",
+    criteria: REQUEST_CRITERIA
+  };
   if (kinds) {
     questions.kind = {
       type: "choice",
@@ -840,14 +1105,17 @@ async function decide(ctx, owners, kinds, text2) {
     };
   }
   const response = await ctx.fetch(
-    new Request(JEV_URL, {
+    new Request(routing.endpoint, {
       method: "POST",
       redirect: "manual",
       headers: { authorization: `Bearer ${apiKey}`, "content-type": "application/json" },
       body: JSON.stringify({ model: routing.model, state: { ticket: text2 }, questions })
     })
   );
-  if (!response.ok) throw new JevError(`HTTP ${response.status}`);
+  if (!response.ok) {
+    await response.body?.cancel();
+    throw new JevError(`HTTP ${response.status}`);
+  }
   const parsed = jevResponseSchema.safeParse(await response.json().catch(() => void 0));
   if (!parsed.success) throw new JevError("invalid response");
   const answer = (question) => {
@@ -871,10 +1139,6 @@ async function decide(ctx, owners, kinds, text2) {
     noRequest: request.choice === "none" && request.confidence >= routing.minConfidence
   };
 }
-function readDecision(stored) {
-  const parsed = decisionSchema.safeParse(parseJson(stored));
-  return parsed.success ? parsed.data : void 0;
-}
 
 // ../../shared/settings.ts
 function settingsLoader(parse) {
@@ -893,89 +1157,90 @@ async function readConfig(env) {
   if (env.CONFIG_KEY === void 0) return typeof env.CONFIG === "string" ? parseJson(env.CONFIG) : env.CONFIG;
   if (env.CONFIG !== void 0) throw new ConfigError("Invalid CONFIG: set either CONFIG or CONFIG_KEY");
   if (!env.CONFIG_STORE) throw new ConfigError("Invalid CONFIG_KEY: requires the CONFIG_STORE KV namespace");
-  const config = await env.CONFIG_STORE.get(env.CONFIG_KEY, "json");
+  const config = await within(env.CONFIG_STORE.get(env.CONFIG_KEY, "json"), AbortSignal.timeout(1500));
   if (config === null) throw new ConfigError("Invalid CONFIG_KEY: not in CONFIG_STORE");
   return config;
 }
 
 // src/config.ts
-import { z as z6 } from "zod";
-var accountId = z6.string().regex(/^[1-9]\d*$/, "must be a Chatwoot account id").refine((value) => Number.isSafeInteger(Number(value)), "must be a safe integer");
-var configSchema = z6.strictObject({
-  chatwoot: z6.strictObject({ baseUrl: z6.url({ protocol: /^https?$/ }) }),
-  reconcile: reconcileSchema,
-  startAfterConversationId: z6.record(accountId, z6.number().int().min(0)).default({}),
-  subrequestBudget: z6.number().int().min(20).max(1e3).default(45),
-  routing: z6.strictObject({
-    model: z6.string().min(1).default("jev-1.13.0"),
+import { z as z5 } from "zod";
+var accountId = z5.string().regex(/^[1-9]\d*$/, "must be a Chatwoot account id").refine((value) => Number.isSafeInteger(Number(value)), "must be a safe integer");
+var configSchema = z5.strictObject({
+  chatwoot: z5.strictObject({ baseUrl: z5.url({ protocol: /^https?$/ }) }),
+  subrequestBudget: z5.number().int().min(45).max(1e3).default(45),
+  routing: z5.strictObject({
+    /** TypeSafe's System One API (/v1/systemone), or another deployment such as a proxy or gateway. */
+    endpoint: z5.url({ protocol: /^https$/ }).default("https://api.typesafe.ai/v1/systemone"),
+    /** Model sent to TypeSafe's System One API; Jev by default. */
+    model: z5.string().min(1).default("jev-1.13.0"),
     /** Jev's probability an answer needs before it is applied. */
-    minConfidence: z6.number().min(0.5).max(1).default(0.7),
-    /**
-     * Snooze a ticket Jev cannot assign yet, and in which the customer asked for nothing yet, until
-     * their next message (see src/routing.ts).
-     */
-    snoozeUnclear: z6.boolean().default(false),
+    minConfidence: z5.number().min(0.5).max(1).default(0.7),
+    /** The account's native Chatwoot agent bot. */
+    botIds: z5.record(accountId, z5.number().int().positive()),
     /** Per Chatwoot account id: the owners Jev chooses from, by a short name. */
-    accounts: z6.record(
+    accounts: z5.record(
       accountId,
-      z6.record(
-        z6.string().regex(/^[a-z0-9_]{1,40}$/, "must be a short lower-case name").refine((name) => name !== "unclear", "unclear is reserved"),
-        z6.strictObject({
+      z5.record(
+        z5.string().regex(/^[a-z0-9_]{1,40}$/, "must be a short lower-case name").refine((name) => name !== "unclear", "unclear is reserved"),
+        z5.strictObject({
           /** Chatwoot user id to assign. */
-          assignee: z6.number().int().positive(),
+          assignee: z5.number().int().positive(),
           /** What the owner handles, as Jev's criterion for choosing them. */
-          covers: z6.string().min(1).max(1e3)
+          covers: z5.string().min(1).max(1e3)
         })
       ).refine((owners) => Object.keys(owners).length > 0, "needs at least one owner")
     ),
     /** Topic labels (Chatwoot label names, lower case) and what each covers. Unset: no topic. */
-    topics: z6.record(
-      z6.string().regex(/^[a-z0-9_-]{1,255}$/, "must be a Chatwoot label name (lower case)"),
-      z6.string().min(1).max(1e3)
+    topics: z5.record(
+      z5.string().regex(/^[a-z0-9_-]{1,255}$/, "must be a Chatwoot label name (lower case)"),
+      z5.string().min(1).max(1e3)
     ).optional(),
     /**
      * Per Chatwoot account id: kinds of ticket Jev recognizes, by a short name, and what is done,
      * once, when it does (see src/routing.ts). Unset: none.
      */
-    kinds: z6.record(
+    kinds: z5.record(
       accountId,
-      z6.record(
-        z6.string().regex(/^[a-z0-9_-]{1,40}$/, "must be a short lower-case name").refine((name) => name !== "none", "none is reserved"),
-        z6.strictObject({
+      z5.record(
+        z5.string().regex(/^[a-z0-9_-]{1,40}$/, "must be a short lower-case name").refine((name) => name !== "none", "none is reserved"),
+        z5.strictObject({
           /** What the kind is, as Jev's criterion for recognizing it. */
-          covers: z6.string().min(1).max(1e3),
+          covers: z5.string().min(1).max(1e3),
           /**
            * Short code of the account's Chatwoot canned response sent to the customer once, as
-           * the account's agent bot (CHATWOOT_BOT_TOKENS). None is sent while it does not exist.
+           * the account's agent bot (CHATWOOT_AGENT_BOT_TOKENS). Missing responses hand off to people.
            */
-          cannedResponse: z6.string().trim().min(1).max(255).optional(),
+          cannedResponse: z5.string().trim().min(1).max(255).optional(),
           /**
            * Set instead of routing the ticket (after the reply, with cannedResponse): `resolved`,
            * or `snoozed` until the customer's next message. A new message from the customer
            * reopens either.
            */
-          status: z6.enum(["resolved", "snoozed"]).optional()
+          status: z5.enum(["resolved", "snoozed"]).optional()
         })
       )
     ).optional()
   })
-}).refine((config) => Object.keys(config.startAfterConversationId).every((id3) => config.routing.accounts[id3]), {
-  path: ["startAfterConversationId"],
-  message: "must only name routed accounts"
-}).refine((config) => Object.keys(config.routing?.kinds ?? {}).every((id3) => config.routing?.accounts[id3]), {
+}).refine(
+  (config) => {
+    const accounts = Object.keys(config.routing.accounts);
+    return accounts.length > 0 && accounts.length === Object.keys(config.routing.botIds).length && accounts.every((id3) => config.routing.botIds[id3] !== void 0);
+  },
+  { path: ["routing", "botIds"], message: "must name exactly the routed accounts" }
+).refine((config) => Object.keys(config.routing.kinds ?? {}).every((id3) => config.routing.accounts[id3]), {
   path: ["routing", "kinds"],
   message: "must only name routed accounts"
 }).refine(
-  (config) => Object.values(config.routing?.kinds ?? {}).every(
-    (kinds) => Object.keys(kinds).every((kind) => !Object.hasOwn(config.routing?.topics ?? {}, kind))
+  (config) => Object.values(config.routing.kinds ?? {}).every(
+    (kinds) => Object.keys(kinds).every((kind) => !Object.hasOwn(config.routing.topics ?? {}, kind))
   ),
   { path: ["routing", "kinds"], message: "a kind cannot be named as a topic: they are labels of two families" }
 );
-var secretsSchema = z6.object({
-  CHATWOOT_TOKEN: z6.string().min(1),
-  CHATWOOT_WEBHOOK_SECRETS: jsonRecord,
-  TYPESAFE_API_KEY: z6.string().min(1),
-  CHATWOOT_BOT_TOKENS: jsonRecord.default({})
+var secretsSchema = z5.object({
+  CHATWOOT_TOKEN: z5.string().min(1),
+  CHATWOOT_AGENT_BOT_SECRETS: jsonRecord,
+  TYPESAFE_API_KEY: z5.string().min(1),
+  CHATWOOT_AGENT_BOT_TOKENS: jsonRecord
 });
 function parseSettings(rawConfig, rawSecrets) {
   const config = configSchema.safeParse(rawConfig);
@@ -985,50 +1250,41 @@ function parseSettings(rawConfig, rawSecrets) {
   return buildSettings(config.data, secrets.data);
 }
 function buildSettings(config, secrets) {
-  for (const accountId2 of Object.keys(config.routing.accounts)) {
-    if (!secrets.CHATWOOT_WEBHOOK_SECRETS[accountId2]) {
-      throw new ConfigError(`Invalid secrets: CHATWOOT_WEBHOOK_SECRETS: account ${accountId2} needs a webhook secret`);
-    }
-  }
-  for (const [accountId2, kinds] of Object.entries(config.routing.kinds ?? {})) {
-    if (Object.values(kinds).some((kind) => kind.cannedResponse) && !secrets.CHATWOOT_BOT_TOKENS[accountId2]) {
-      throw new ConfigError(`Invalid secrets: CHATWOOT_BOT_TOKENS: account ${accountId2} has kinds that reply`);
+  const accounts = Object.keys(config.routing.accounts);
+  for (const name of ["CHATWOOT_AGENT_BOT_SECRETS", "CHATWOOT_AGENT_BOT_TOKENS"]) {
+    if (Object.keys(secrets[name]).length !== accounts.length || accounts.some((id3) => !secrets[name][id3]?.trim())) {
+      throw new ConfigError(`Invalid secrets: ${name}: needs exactly the routed accounts`);
     }
   }
-  return { config, secrets, botToken: (accountId2) => secrets.CHATWOOT_BOT_TOKENS[String(accountId2)] };
+  return { config, secrets };
 }
 
 // src/settings.ts
 var loadSettings = settingsLoader(parseSettings);
 
 // src/router.ts
-var ROUTER_NAME = "global";
-var ROUTE_BUDGET = 15;
-var BUDGET = { route: ROUTE_BUDGET, sweep: 1 };
+function conversationName(accountId2, conversationId) {
+  return `${accountId2}:${conversationId}`;
+}
+var ROUTE_BUDGET = 45;
 var RUN_WALL_MS = 5 * 60 * 1e3;
-var id = z7.number().int().positive();
-var jobSchema = z7.discriminatedUnion("type", [
-  z7.object({ type: z7.literal("route"), accountId: id, conversationId: id }),
-  z7.object({ type: z7.literal("sweep"), accountId: id })
+var id = z6.number().int().positive();
+var jobSchema = z6.discriminatedUnion("type", [
+  z6.object({ type: z6.literal("route"), accountId: id, conversationId: id })
 ]);
 var Router = class extends DurableObject {
   store;
   constructor(context, env) {
     super(context, env);
     this.store = new QueueStore(context.storage.sql);
-    context.blockConcurrencyWhile(async () => this.store.migrate());
+    this.store.migrate();
   }
-  async enqueueConversation(accountId2, conversationId) {
+  async enqueueConversation(accountId2, conversationId, transition) {
     const settings = await loadSettings(this.env);
     if (!routesAccount(settings, accountId2)) return;
+    if (transition) expectActivity(this.store, accountId2, conversationId, transition);
     this.enqueue({ type: "route", accountId: accountId2, conversationId });
-    await this.schedule();
-  }
-  async requestSweep() {
-    for (const accountId2 of Object.keys((await loadSettings(this.env)).config.routing.accounts)) {
-      this.enqueue({ type: "sweep", accountId: Number(accountId2) });
-    }
-    await this.schedule();
+    await scheduleAlarm(this.ctx, this.store.nextWakeup());
   }
   async alarm() {
     const settings = await loadSettings(this.env);
@@ -1045,21 +1301,18 @@ var Router = class extends DurableObject {
         continue;
       }
       const payload = parsed.data;
-      if (budget.remaining < BUDGET[payload.type] || Date.now() - started > RUN_WALL_MS) {
+      if (budget.remaining < ROUTE_BUDGET || Date.now() - started > RUN_WALL_MS) {
         yielded = true;
         break;
       }
       try {
-        const ctx = { settings, chatwoot, store: this.store, fetch: budget.fetch };
-        if (payload.type === "route") {
-          if (await routeConversation(ctx, payload.accountId, payload.conversationId) === "defer") {
-            this.store.deferJob(job);
-            yielded = true;
-            break;
-          }
-        } else if (routesAccount(settings, payload.accountId)) {
-          await this.sweep(settings, chatwoot, payload.accountId);
+        const ctx = { settings, chatwoot, store: this.store, fetch: budget.fetchWith(JOB_SLICE_MS) };
+        if (await routeConversation(ctx, payload.accountId, payload.conversationId) === "defer") {
+          this.store.deferJob(job);
+          yielded = true;
+          break;
         }
+        clearFailures(this.store, payload.accountId, payload.conversationId);
         this.store.completeJob(job);
       } catch (error) {
         if (error instanceof ChatwootError && error.conversationMissing) {
@@ -1072,48 +1325,122 @@ var Router = class extends DurableObject {
           yielded = true;
           break;
         }
-        const delay = retryDelay(job.attempts);
-        const logAt = job.attempts + 1 >= 3 ? log.error : log.warn;
+        const attempts = recordFailure(this.store, payload.accountId, payload.conversationId);
+        const delay = retryDelay(attempts - 1);
+        const logAt = attempts >= 3 ? log.error : log.warn;
         logAt("job failed; will retry", {
           job: job.key,
-          attempts: job.attempts + 1,
+          attempts,
           delayMs: delay,
           ...errorFields(error)
         });
         this.store.retryJob(job, delay);
       }
     }
-    await this.schedule(yielded ? Date.now() : void 0);
-  }
-  async sweep(settings, chatwoot, accountId2) {
-    const pass = readSweepPass(this.store, accountId2, settings.config.reconcile);
-    const conversations = await chatwoot.listConversations(accountId2, pass.page);
-    let finished = conversations.length === 0;
-    for (const conversation of conversations) {
-      if ((conversation.last_activity_at ?? 0) < pass.cutoff) {
-        finished = true;
-        break;
-      }
-      const conversationId = conversation.id;
-      if (conversationId === void 0) continue;
-      this.enqueue({ type: "route", accountId: accountId2, conversationId });
-    }
-    if (finished) {
-      saveSweepPass(this.store, accountId2, pass);
-    } else {
-      saveSweepPass(this.store, accountId2, pass, pass.page + 1);
-      this.enqueue({ type: "sweep", accountId: accountId2 });
-    }
+    await scheduleAlarm(this.ctx, yielded ? Date.now() : this.store.nextWakeup());
   }
   enqueue(payload) {
-    const key = payload.type === "sweep" ? `sweep:${payload.accountId}` : `${payload.type}:${payload.accountId}:${payload.conversationId}`;
-    this.store.enqueue(key, payload.type === "sweep" ? 1 : 0, JSON.stringify(payload));
+    this.store.enqueue(`route:${payload.accountId}:${payload.conversationId}`, 0, JSON.stringify(payload));
   }
-  async schedule(at) {
-    const next = at ?? this.store.nextWakeup();
-    if (next === void 0) return;
-    const current = await this.ctx.storage.getAlarm();
-    if (current === null || current > next) await this.ctx.storage.setAlarm(next);
+};
+
+// src/coordinator.ts
+var COORDINATOR_NAME = "global";
+var sweepSchema = z7.object({ accountId: z7.number().int().positive(), status: z7.enum(["pending", "open"]) });
+var pageSchema = z7.object({
+  page: z7.number().int().positive()
+});
+var deliverySchema = z7.object({
+  accountId: z7.number().int().positive(),
+  conversationId: z7.number().int().positive()
+});
+var Coordinator = class extends DurableObject2 {
+  store;
+  constructor(ctx, env) {
+    super(ctx, env);
+    this.store = new QueueStore(ctx.storage.sql);
+    this.store.migrate();
+  }
+  async requestSweep() {
+    for (const accountId2 of Object.keys((await loadSettings(this.env)).config.routing.accounts)) {
+      for (const status of ["pending", "open"]) {
+        this.store.enqueue(`sweep:${accountId2}:${status}`, 0, JSON.stringify({ accountId: Number(accountId2), status }));
+      }
+    }
+    await scheduleAlarm(this.ctx, this.store.nextWakeup());
+  }
+  async alarm() {
+    const settings = await loadSettings(this.env);
+    const budget = new Budget(settings.config.subrequestBudget);
+    budget.startSlice();
+    const job = this.store.nextDueJobs(1, "sweep:")[0];
+    if (job) {
+      const parsed = sweepSchema.safeParse(parseJson(job.payload));
+      if (!parsed.success) this.store.deleteJob(job.key);
+      else {
+        try {
+          const { accountId: accountId2, status } = parsed.data;
+          const chatwoot = chatwootClient(
+            settings.config.chatwoot.baseUrl,
+            settings.secrets.CHATWOOT_TOKEN,
+            budget.fetch
+          );
+          const saved = pageSchema.safeParse(parseJson(this.store.get(job.key)));
+          const checkpoint = saved.success ? saved.data : { page: 1 };
+          const botId = settings.config.routing.botIds[String(accountId2)];
+          const conversations = await chatwoot.listConversations(accountId2, checkpoint.page, status);
+          this.ctx.storage.transactionSync(() => {
+            for (const conversation of conversations) {
+              if (conversation.id !== void 0 && (status === "pending" || conversation.meta?.assignee_type === "AgentBot" && conversation.meta.assignee?.id === botId))
+                this.store.enqueue(
+                  `delivery:${accountId2}:${conversation.id}`,
+                  1,
+                  JSON.stringify({ accountId: accountId2, conversationId: conversation.id })
+                );
+            }
+            if (conversations.length === 0) {
+              this.store.delete(job.key);
+              this.store.completeJob(job);
+            } else {
+              this.store.set(job.key, JSON.stringify({ page: checkpoint.page + 1 }));
+              this.store.deferJob(job);
+            }
+          });
+        } catch (error) {
+          this.store.retryJob(job, retryDelay(job.attempts));
+          log.warn("sweep page failed; will retry", { job: job.key, ...errorFields(error) });
+        }
+      }
+    }
+    const deliveries = this.store.nextDueJobs(12, "delivery:");
+    for (let start = 0; start < deliveries.length; start += 3) {
+      if (budget.remaining < 3) break;
+      await Promise.all(
+        deliveries.slice(start, start + 3).map(async (child) => {
+          const target = deliverySchema.safeParse(parseJson(child.payload));
+          if (!target.success) {
+            this.store.deleteJob(child.key);
+            return;
+          }
+          const { accountId: accountId2, conversationId } = target.data;
+          try {
+            budget.consume();
+            await within(
+              this.env.ROUTER.getByName(conversationName(accountId2, conversationId)).enqueueConversation(
+                accountId2,
+                conversationId
+              ),
+              budget.controlSignal(200)
+            );
+            this.store.completeJob(child);
+          } catch (error) {
+            this.store.retryJob(child, retryDelay(child.attempts));
+            log.warn("sweep child delivery delayed", { accountId: accountId2, conversationId, ...errorFields(error) });
+          }
+        })
+      );
+    }
+    await scheduleAlarm(this.ctx, this.store.nextWakeup());
   }
 };
 
@@ -1127,15 +1454,27 @@ var eventSchema = z8.object({
   conversation: z8.object({ id: id2 }).optional(),
   message_type: z8.union([z8.string(), z8.number()]).optional(),
   private: z8.boolean().optional(),
+  updated_at: z8.number().optional(),
+  changed_attributes: z8.array(z8.object({ status: z8.object({ previous_value: z8.string(), current_value: z8.string() }).optional() })).optional(),
   sender: z8.object({ type: z8.string().optional() }).nullish()
 });
-var CONVERSATION_EVENTS = /* @__PURE__ */ new Set(["conversation_created", "conversation_updated", "conversation_status_changed"]);
+var CONVERSATION_EVENTS = /* @__PURE__ */ new Set([
+  "conversation_opened",
+  "conversation_resolved",
+  "conversation_updated",
+  "conversation_status_changed"
+]);
 function eventTarget(payload) {
   const parsed = eventSchema.safeParse(payload);
   if (!parsed.success) return void 0;
   const event = parsed.data;
   if (CONVERSATION_EVENTS.has(event.event) && event.id !== void 0) {
-    return { accountId: event.account.id, conversationId: event.id };
+    const change = event.changed_attributes?.find((entry) => entry.status)?.status;
+    return {
+      accountId: event.account.id,
+      conversationId: event.id,
+      ...change && (change.previous_value === "pending" || change.current_value === "resolved" || change.current_value === "pending" && change.previous_value !== "resolved") && event.updated_at !== void 0 ? { transition: { status: change.current_value, at: event.updated_at } } : {}
+    };
   }
   if (event.event === "message_created" && (event.message_type === "incoming" || event.message_type === 0) && !event.private && event.sender?.type === "contact" && event.id !== void 0 && event.conversation) {
     return { accountId: event.account.id, conversationId: event.conversation.id };
@@ -1154,7 +1493,7 @@ app.get("/healthz", async (context) => {
     return context.json({ ok: false }, 503);
   }
 });
-app.post("/chatwoot/webhook", bodyLimit({ maxSize: 2 * 1024 * 1024 }), async (context) => {
+app.post("/chatwoot/agent-bot", bodyLimit({ maxSize: 2 * 1024 * 1024 }), async (context) => {
   const settings = await loadSettings(context.env);
   const timestamp = context.req.header("x-chatwoot-timestamp");
   if (!timestamp || !isFreshTimestamp(timestamp, Math.floor(Date.now() / 1e3))) {
@@ -1163,7 +1502,7 @@ app.post("/chatwoot/webhook", bodyLimit({ maxSize: 2 * 1024 * 1024 }), async (co
   const body = new Uint8Array(await context.req.arrayBuffer());
   const signature = context.req.header("x-chatwoot-signature");
   let signedBy;
-  for (const [accountId2, secret] of Object.entries(settings.secrets.CHATWOOT_WEBHOOK_SECRETS)) {
+  for (const [accountId2, secret] of Object.entries(settings.secrets.CHATWOOT_AGENT_BOT_SECRETS)) {
     if (await verifyChatwootSignature(secret, timestamp, body, signature)) {
       signedBy = Number(accountId2);
       break;
@@ -1181,7 +1520,14 @@ app.post("/chatwoot/webhook", bodyLimit({ maxSize: 2 * 1024 * 1024 }), async (co
   if (target.accountId !== signedBy || !routesAccount(settings, target.accountId)) {
     return context.text("account does not match the webhook secret", 403);
   }
-  await context.env.ROUTER.getByName(ROUTER_NAME).enqueueConversation(target.accountId, target.conversationId);
+  await within(
+    context.env.ROUTER.getByName(conversationName(target.accountId, target.conversationId)).enqueueConversation(
+      target.accountId,
+      target.conversationId,
+      target.transition
+    ),
+    AbortSignal.timeout(METADATA_TIMEOUT_MS)
+  );
   return context.json({ ok: true });
 });
 app.notFound((context) => context.text("not found", 404));
@@ -1192,10 +1538,13 @@ app.onError((error, context) => {
 var src_default = {
   fetch: app.fetch,
   async scheduled(_controller, env, context) {
-    context.waitUntil(env.ROUTER.getByName(ROUTER_NAME).requestSweep());
+    context.waitUntil(
+      within(env.COORDINATOR.getByName(COORDINATOR_NAME).requestSweep(), AbortSignal.timeout(METADATA_TIMEOUT_MS))
+    );
   }
 };
 export {
+  Coordinator,
   Router,
   src_default as default
 };