@agentprojectcontext/apx 1.81.0 → 1.89.1

package/src/core/channels/telegram/ask-callbacks.js

@@ -13,6 +13,12 @@ import { getRecentTelegramTurnsFromFs, appendGlobalMessage } from "#core/stores/
 import { CHANNELS } from "#core/constants/channels.js";
 import { SUPERAGENT_ACTOR_ID } from "#core/identity/index.js";
 import { applyNudgeCallback } from "#core/nudge/index.js";
+import { recordDelivery } from "#core/stores/deliveries.js";
+import { silenceMobilityToday } from "#core/mobility/preferences.js";
+import { getMobilityAlert, recordMobilityResponse } from "#core/mobility/state.js";
+import { answerMobilityAlert } from "#core/mobility/answer.js";
+import { doneTask } from "#core/stores/tasks.js";
+import { resolveLang } from "#core/i18n/index.js";
 
 /**
  * The label the user actually tapped, recovered from the keyboard attached to
@@ -52,6 +58,10 @@ export async function handleCallbackQuery(self, callbackQuery) {
     await handleNudgeCallback(self, callbackQuery);
     return;
   }
+  if (data.startsWith("apx:mobility:")) {
+    await handleMobilityCallback(self, callbackQuery);
+    return;
+  }
   const adapter = createTelegramConfirmAdapter({
     token: resolveBotToken(self.channel),
     chatId: callbackQuery.message?.chat?.id,
@@ -94,6 +104,98 @@ export async function handleCallbackQuery(self, callbackQuery) {
   });
 }
 
+/**
+ * A proximity chip: "voy" / "hoy no" while driving, "hecho" / "todavía no"
+ * when the follow-up comes back after the trip. Each one carries the alert id
+ * (apx:mobility:<action>:<id>) because the answer has to land on the ONE place
+ * it was asked about — the owner can have two of these open at once, and a
+ * bare "yes" would close whichever came last.
+ */
+export async function handleMobilityAlertCallback(self, callbackQuery, action, alertId) {
+  const lang = resolveLang(self.globalConfig);
+  const alert = getMobilityAlert(alertId);
+  if (!alert) {
+    await self._answerCallback({ callback_query_id: callbackQuery.id });
+    await clearKeyboard(self, callbackQuery);
+    self.log(`telegram[${self.channel.name}] mobility alert ${alertId} is gone`);
+    return;
+  }
+
+  // The answer itself lives in core (core/mobility/answer.js) so a tap here
+  // and a tap on the car card mean the same thing. This adapter supplies the
+  // one piece core cannot have: resolving the project a task lives in.
+  const { ack } = answerMobilityAlert(alertId, action, {
+    lang,
+    closeTask: (target) => {
+      const closed = closeAlertTask(self, target);
+      if (!closed) self.log(`telegram[${self.channel.name}] mobility task ${target.task_id} not found — nothing closed`);
+      return closed;
+    },
+  });
+  await self._answerCallback({ callback_query_id: callbackQuery.id, text: ack });
+  await clearKeyboard(self, callbackQuery);
+}
+
+/**
+ * Close the task the alert was about. The alert stores the project the task
+ * came from, so this resolves that project rather than searching every one —
+ * two projects can hold tasks with the same short id prefix.
+ */
+function closeAlertTask(self, alert) {
+  if (!alert.task_id) return false;
+  let storagePath = null;
+  try {
+    storagePath = self.projects.get(alert.project_id)?.storagePath || null;
+  } catch {
+    storagePath = null;
+  }
+  if (!storagePath) return false;
+  try {
+    return Boolean(doneTask(storagePath, alert.task_id, "mobility"));
+  } catch (error) {
+    self.log(`telegram[${self.channel.name}] could not close task: ${error.message}`);
+    return false;
+  }
+}
+
+export async function handleMobilityCallback(self, callbackQuery) {
+  const parts = String(callbackQuery.data || "").split(":");
+  const action = parts[2] || "";
+  const alertId = parts[3] || "";
+  if (alertId) return handleMobilityAlertCallback(self, callbackQuery, action, alertId);
+  recordMobilityResponse(action);
+  const chatId = callbackQuery.message?.chat?.id;
+  let ack = "Listo.";
+  let response = "";
+  if (action === "later") {
+    const project = self.resolveProject();
+    const original = String(callbackQuery.message?.text || "recordatorio de viaje").slice(0, 500);
+    const id = project?.storagePath ? recordDelivery(project.storagePath, {
+      agent: "super_agent",
+      agentName: "Roby",
+      routine: "mobility-reminder",
+      notify: `Recordatorio pospuesto por usuario: ${original}`,
+      priority: false,
+      project_id: project.id,
+    }) : null;
+    ack = id ? "Lo guardé para próxima ronda." : "No pude guardar el recordatorio.";
+    response = ack;
+  } else if (action === "silence") {
+    silenceMobilityToday();
+    ack = "Sin avisos de viaje por hoy.";
+    response = ack;
+  } else if (action === "yes" || action === "no") {
+    // Retired from the trip card — they asked "¿vas ahora?" and did nothing
+    // with the answer. Still handled because cards carrying them are sitting
+    // in the chat history on a phone, and a button that answers nothing is
+    // worse than an outdated one.
+    ack = action === "yes" ? "Marcado: vas ahora." : "Entendido: no vas ahora.";
+  }
+  await self._answerCallback({ callback_query_id: callbackQuery.id, text: ack });
+  await clearKeyboard(self, callbackQuery);
+  if (response && chatId) await self._send({ chat_id: chatId, text: response });
+}
+
 /** Best-effort: take the keyboard off a message whose buttons are now dead. */
 async function clearKeyboard(self, callbackQuery) {
   const chatId = callbackQuery.message?.chat?.id;
@@ -352,6 +454,7 @@ export async function runResumedTurn(self, ctx) {
     saTrace,
     streamedCount: state.streamedCount,
     lastStreamedText: state.lastStreamedText,
+    heldCount: state.heldCount,
     agentDisplay,
     extraMeta: { ask_resume: true },
   });

package/src/core/channels/telegram/dispatch.js

@@ -17,21 +17,39 @@ import { getRecentTelegramTurnsFromFs, appendGlobalMessage } from "#core/stores/
 import { compactChannelIfNeeded, agentScopedMemoryBlock } from "#core/memory/index.js";
 import { readAgents } from "#core/apc/parser.js";
 import { buildAgentSystem } from "#core/agent/build-agent-system.js";
+import { resolveAgentModel } from "#core/agent/agent-model.js";
 import { resolveAgentName, SUPERAGENT_ACTOR_ID } from "#core/identity/index.js";
 import { registerSender, resolveAllowedTools } from "#core/identity/telegram.js";
 import { buildRelationshipBlock } from "#core/agent/index.js";
+import { authorLine } from "#core/agent/author-line.js";
 import { CHANNELS } from "#core/constants/channels.js";
 import { tryResolveSkillCommand } from "#core/agent/skills/trigger.js";
 import * as askFlow from "./ask.js";
-import { telegramAuthorLabel } from "./helpers.js";
+import { telegramAuthorLabel, releaseActiveRequest, isImpatientResend } from "./helpers.js";
 import { handleIncomingPhoto } from "./inbound/photo.js";
 import { handleIncomingAudio } from "./inbound/audio.js";
 import { handleIncomingFile, detectIncomingFile } from "./inbound/file.js";
 import { buildStreamHandler, runTelegramSuperAgent, telegramErrorText, sendFinalReply, runFollowupTurn } from "./reply.js";
 import { t, resolveLang } from "#core/i18n/index.js";
+import { isMobilitySilenceCommand, silenceMobilityToday } from "#core/mobility/preferences.js";
 
 const nowIso = () => new Date().toISOString().replace(/\.\d{3}Z$/, "Z");
 
+// One Telegram message = ONE stored record. The media handlers used to append
+// their own row AND rewrite `text`, so dispatch's inbound log stored the same
+// turn a second time: the viewer showed it twice, the current transcript landed
+// in its own history (the media row was already on disk by the time we read it
+// back), and the next turn replayed it twice more. They now return what they
+// archived and this folds it into the single inbound record, so the file
+// metadata (local_path, file_id, …) is not lost with the duplicate.
+function mediaMeta(media) {
+  if (!media.length) return {};
+  return {
+    ...Object.assign({}, ...media.map((m) => m.meta)),
+    media_kind: media.length === 1 ? media[0].kind : media.map((m) => m.kind),
+  };
+}
+
 export async function handleUpdate(self, u) {
     self.lastUpdateAt = nowIso();
 
@@ -72,43 +90,103 @@ export async function handleUpdate(self, u) {
     // Role-based tool gating for the super-agent path (guests → no tools).
     const allowedTools = resolveAllowedTools(self.globalConfig, sender);
 
-    // Default Interrupt: abort any running request for this chat_id
+    // What the user actually typed, needed before the interrupt decision below.
+    // Media handlers rewrite it further down; a resend is plain text, so the raw
+    // field is enough here.
+    let text = msg.text || msg.caption || "";
+    if (isMobilitySilenceCommand(text)) silenceMobilityToday();
+
+    // Default Interrupt: a new message aborts the running turn for this chat —
+    // "no, stop, do this instead". Except when the "new" message is the SAME
+    // one the turn is already working on: that is the user checking whether a
+    // quiet turn is still alive, and aborting it restarts the work from zero
+    // (see isImpatientResend). Then we let the running turn finish and say so.
     if (chat_id) {
       const prev = self.activeRequests.get(chat_id);
+      if (prev && isImpatientResend(prev, text)) {
+        const secs = Math.round((Date.now() - prev.startedAt) / 1000);
+        self.log(
+          `telegram[${self.channel.name}] resend of the in-flight message for chat ${chat_id} ` +
+          `(${secs}s in) — keeping the running turn`
+        );
+        // Logged so the history is honest about what was sent, flagged so the
+        // turn that eventually answers knows it was asked twice.
+        appendGlobalMessage({
+          channel: CHANNELS.TELEGRAM,
+          direction: "in",
+          type: "user",
+          actor_id: msg.from?.id ? String(msg.from.id) : author,
+          external_id: String(u.update_id),
+          author,
+          body: text,
+          meta: {
+            chat_id,
+            user_id: msg.from?.id || null,
+            message_id: msg.message_id,
+            tg_channel: self.channel.name,
+            resend_of_in_flight: true,
+          },
+        });
+        try {
+          // Its own words, from the situation — not a canned "please wait".
+          const line = await authorLine({
+            globalConfig: self.globalConfig,
+            instruction:
+              `You are ${Math.round(secs / 60) || 1} minute(s) into working on exactly this request ` +
+              `and the user just sent it again, which means the quiet made them think you stopped. ` +
+              `In ONE short line: you are still on it, and say what you are doing right now. ` +
+              `Do not restart, do not apologise at length, do not promise a time.`,
+          });
+          if (line) await self._send({ chat_id, text: line });
+        } catch (e) {
+          self.log(`telegram[${self.channel.name}] resend ack failed: ${e.message}`);
+        }
+        return;
+      }
       if (prev) {
         self.log(`telegram[${self.channel.name}] interrupting previous request for chat ${chat_id}`);
         prev.abort();
       }
     }
     const abortCtrl = new AbortController();
+    // The turn's own text and start time ride on the controller so the next
+    // inbound can tell "do something else" from "are you still there".
+    abortCtrl.text = text;
+    abortCtrl.startedAt = Date.now();
     if (chat_id) self.activeRequests.set(chat_id, abortCtrl);
 
-    let text = msg.text || msg.caption || "";
-
     // ── Incoming media ────────────────────────────────────────────────────
-    // Photo and voice/audio each download + archive the file and rewrite `text`
-    // so the rest of the pipeline treats them like a typed message. The handlers
-    // live in ./inbound/ to keep this dispatcher focused on routing. Each one
+    // Photo, voice/audio and files each download the attachment and rewrite
+    // `text` so the rest of the pipeline treats them like a typed message; the
+    // file metadata comes back in `media` and is stored on the single inbound
+    // record below. The handlers live in ./inbound/ to keep this dispatcher
+    // focused on routing. Each one
     // injects a marker so a caption-less attachment is never an empty turn:
     // photos an `[image]` marker (plus the pixels, as an attachment, for a
     // multimodal engine), audio its `[audio]` transcript, files a description
     // with the local path.
     const attachments = [];
+    const media = [];   // what the handlers downloaded, folded into the inbound record below
     if (msg.photo && msg.photo.length > 0) {
-      let attachment;
-      ({ text, attachment } = await handleIncomingPhoto(self, { msg, u, author, chat_id, text }));
+      let attachment, archived;
+      ({ text, attachment, media: archived } = await handleIncomingPhoto(self, { msg, text }));
       if (attachment) attachments.push(attachment);
+      if (archived) media.push(archived);
     }
     const incomingAudio = msg.voice || msg.audio;
     if (incomingAudio && incomingAudio.file_id) {
-      ({ text } = await handleIncomingAudio(self, { msg, u, author, chat_id, text, incomingAudio }));
+      let archived;
+      ({ text, media: archived } = await handleIncomingAudio(self, { chat_id, text, incomingAudio }));
+      if (archived) media.push(archived);
     }
     // Documents, video, video notes and GIFs. Without this a file sent with no
     // caption left `text` empty, the turn was dropped, and the bot answered
     // nothing at all.
     const incomingFile = detectIncomingFile(msg);
     if (incomingFile) {
-      ({ text } = await handleIncomingFile(self, { msg, u, author, chat_id, text, incoming: incomingFile }));
+      let archived;
+      ({ text, media: archived } = await handleIncomingFile(self, { text, incoming: incomingFile }));
+      if (archived) media.push(archived);
     }
 
     // If there's a pending ask_questions flow for this chat AND the current
@@ -125,6 +203,7 @@ export async function handleUpdate(self, u) {
         author,
         body: text,
         meta: {
+          ...mediaMeta(media),
           chat_id,
           user_id: msg.from?.id || null,
           message_id: msg.message_id,
@@ -188,6 +267,7 @@ export async function handleUpdate(self, u) {
       author,
       body: text,
       meta: {
+        ...mediaMeta(media),
         chat_id,
         user_id: msg.from?.id || null,
         message_id: msg.message_id,
@@ -197,20 +277,37 @@ export async function handleUpdate(self, u) {
 
     // Super-agent is ALWAYS active on Telegram: respond_with_engine === false
     // used to silently drop user messages, which looked to the user like the
-    // bot ignored them. Honour the legacy flag only as a soft hint (skip the
+    // bot ignored them. Honour the flag only as a soft hint (skip the
     // routed-agent shortcut so we fall straight to super-agent) but never let
     // it short-circuit the whole reply. To genuinely silence the bot, disable
     // the channel entirely (telegram.enabled = false in config).
     const skipRoutedAgent = self.channel.respond_with_engine === false;
     if (!text) return;
 
-    // Short-circuit /reset / /new: send an ack and don't engage the engine.
-    // The marker we just logged is enough — getRecentTelegramTurns will
-    // honor it for future messages.
+    // Short-circuit /reset / /new: confirm and stop. No turn runs — the one
+    // model call below writes the confirmation itself, it does not answer the
+    // command. The marker we just logged is enough — getRecentTelegramTurns
+    // will honor it for future messages.
     if (isReset) {
       try {
-        const ack = t("telegram.reset_ack", { lang: resolveLang(self.globalConfig) });
+        // The ack is ours to trigger, not to word: the model writes it, and the
+        // canned line is only what goes out if it can't (engine down, no model
+        // configured). See core/agent/author-line.js.
+        const lang = resolveLang(self.globalConfig);
+        // Writing it takes a second or two, which on a chat reads as nothing
+        // happening — the same indicator a normal turn puts up covers it.
+        const stopAckTyping = self._startTyping(chat_id);
+        let ack;
+        try {
+          ack = (await authorLine({
+            globalConfig: self.globalConfig,
+            instruction: "The user just cleared this conversation — from here you remember none of it and the thread starts fresh. Confirm that in one line and invite what comes next.",
+          })) || t("telegram.reset_ack", { lang });
+        } finally {
+          stopAckTyping();
+        }
         await self._send({ chat_id, text: ack });
+        // attribution-exempt: /reset ack — a short model-authored line whose attribution the ack path does not surface.
         appendGlobalMessage({
           channel: CHANNELS.TELEGRAM,
           direction: "out",
@@ -231,6 +328,11 @@ export async function handleUpdate(self, u) {
     // Start "typing..." indicator. Stops when we send the reply (or fail).
     const stopTyping = self._startTyping(chat_id);
 
+    // Detach the model turn from the poll loop. Awaiting it here used to freeze
+    // getUpdates for the whole run, so a newer Telegram message could never
+    // abort this one — Default Interrupt existed, but never fired.
+    const replyTurn = (async () => {
+
     // Preset to the super-agent defaults so every exit path (including one where
     // neither the routed-agent nor the super-agent branch runs) has a valid
     // actor — the routed-agent / super-agent branches override these on success,
@@ -242,16 +344,20 @@ export async function handleUpdate(self, u) {
     let replyModel = null;                    // model that actually produced the reply
     let replyUsage = null;                    // token accounting for this turn
     let replyTrace = null;                    // what the turn actually did (summarised on the message)
+    let replyJudge = null;                    // verdict trail, when the turn was continued past a stop
     const projectCfg = target.config || self.globalConfig;
     // Display name for the super-agent persona on this channel (from identity.json).
     const agentDisplay = resolveAgentName(self.globalConfig);
 
-    // Try the project's chosen agent first (skipped if the legacy
+    // Try the project's chosen agent first (skipped when the
     // respond_with_engine === false hint asked to bypass routed agents).
     const routeSlug = skipRoutedAgent ? null : self.channel.route_to_agent;
     if (routeSlug) {
       const agent = readAgents(target.path).find((a) => a.slug === routeSlug);
-      if (agent && agent.fields.Model) {
+      // An agent that inherits its model is still usable: the router resolves
+      // one for it, same as a direct chat.
+      const agentModel = agent ? await resolveAgentModel({ agent, config: projectCfg }) : null;
+      if (agent && agentModel) {
         try {
           const scopedMemory = await agentScopedMemoryBlock(text, { project: target, agent, config: projectCfg });
           const system = buildAgentSystem(target, agent, {
@@ -261,18 +367,19 @@ export async function handleUpdate(self, u) {
             extraParts: [relationshipBlock, scopedMemory].filter(Boolean),
           });
           const result = await callEngine({
-            modelId: agent.fields.Model,
+            modelId: agentModel,
             system,
             messages: [{ role: "user", content: text }],
             config: projectCfg,
+            signal: abortCtrl.signal,
           });
           replyText = result.text;
           replyAuthor = agent.slug;
           replyActorId = agent.slug;
           replyKind = "agent";
-          // Fully-qualified id from the agent card (provider:model) — callEngine
-          // resolves it internally and doesn't hand it back.
-          replyModel = agent.fields.Model;
+          // Fully-qualified id (provider:model) — callEngine resolves it
+          // internally and doesn't hand it back.
+          replyModel = agentModel;
           replyUsage = result.usage || null;
         } catch (e) {
           self.log(`telegram[${self.channel.name}] agent reply failed: ${e.message}`);
@@ -293,13 +400,15 @@ export async function handleUpdate(self, u) {
       }
     }
 
-    // Fallback: super-agent — STREAMED. Each iteration's assistant text is sent
-    // to Telegram as its own message the moment the model produces it; tool
-    // calls are logged but never sent (internal). The streamed turn + its final
-    // send live in ./reply.js so this dispatcher and the ask-flow resume
+    // Fallback: super-agent — STREAMED, but not narrated step by step. One
+    // notice goes out when work starts, the notes before every later step are
+    // held (./progress-gate.js), and the closing message carries the result;
+    // tool calls are logged but never sent (internal). The streamed turn + its
+    // final send live in ./reply.js so this dispatcher and the ask-flow resume
     // (_runResumedTurn in the host poller) share ONE reply path — no drift.
     let streamedCount = 0;
     let lastStreamedText = "";
+    let heldCount = 0;
     if (!replyText && isSuperAgentEnabled(self.globalConfig)) {
       const { onEvent, state } = buildStreamHandler(self, { chat_id, update_id: u.update_id, agentDisplay });
 
@@ -351,6 +460,7 @@ export async function handleUpdate(self, u) {
         replyKind = "superagent";
         replyUsage = sa.usage;
         replyTrace = sa.trace || null;
+        replyJudge = sa.judge || null;
         replyModel = sa.model || state.model || null;
 
         // ── ask_questions integration ────────────────────────────────────
@@ -360,7 +470,7 @@ export async function handleUpdate(self, u) {
         // (via _runResumedTurn) once every answer is collected.
         const askQuestions = askFlow.extractAskQuestionsFromTrace(sa.trace);
         if (askQuestions && chat_id) {
-          self.activeRequests.delete(chat_id);
+          releaseActiveRequest(self.activeRequests, chat_id, abortCtrl);
           stopTyping();
           try {
             await self._startAskFlow({
@@ -383,12 +493,13 @@ export async function handleUpdate(self, u) {
         }
         streamedCount = state.streamedCount;
         lastStreamedText = state.lastStreamedText;
+        heldCount = state.heldCount;
       } catch (e) {
         if (abortCtrl.signal.aborted) {
           // A newer message superseded this one. Whatever streamed so far is
           // already sent + logged; the newer message's run continues the thread.
           self.log(`telegram[${self.channel.name}] request aborted for chat ${chat_id}`);
-          if (chat_id) self.activeRequests.delete(chat_id);
+          releaseActiveRequest(self.activeRequests, chat_id, abortCtrl);
           stopTyping();
           return;
         }
@@ -402,7 +513,13 @@ export async function handleUpdate(self, u) {
       }
     }
 
-    if (chat_id) self.activeRequests.delete(chat_id);
+    if (abortCtrl.signal.aborted) {
+      self.log(`telegram[${self.channel.name}] request aborted for chat ${chat_id}`);
+      releaseActiveRequest(self.activeRequests, chat_id, abortCtrl);
+      stopTyping();
+      return;
+    }
+    releaseActiveRequest(self.activeRequests, chat_id, abortCtrl);
     stopTyping();
     await sendFinalReply(self, {
       chat_id,
@@ -416,7 +533,14 @@ export async function handleUpdate(self, u) {
       saTrace: replyTrace,
       streamedCount,
       lastStreamedText,
+      heldCount,
       agentDisplay,
+      // Recoverable after the fact: this turn ran longer because a verdict said
+      // it wasn't finished, not because the model rambled.
+      extraMeta: replyJudge ? { judge: replyJudge } : {},
+    });
+    })();
+    replyTurn.catch((e) => {
+      self.log(`telegram[${self.channel.name}] reply turn crashed: ${e.message}`);
     });
   }
-

package/src/core/channels/telegram/helpers.js

@@ -76,7 +76,7 @@ export function loadState() {
   if (!fs.existsSync(TELEGRAM_STATE_PATH)) return { channels: {} };
   try {
     const raw = JSON.parse(fs.readFileSync(TELEGRAM_STATE_PATH, "utf8"));
-    return { channels: raw.channels || {}, _legacy_offset: raw.offset || 0 };
+    return { channels: raw.channels || {} };
   } catch {
     return { channels: {} };
   }
@@ -116,8 +116,9 @@ export function tokenSource(channel) {
 }
 
 /**
- * Resolve the list of telegram channels to poll, honouring both the
- * canonical telegram.channels[] and the legacy single-channel mode.
+ * Resolve the list of telegram channels to poll. Credentials live in
+ * telegram.channels[]; with none configured we fall back to a single implicit
+ * "default" channel whose token/chat id come from the environment.
  */
 export function resolveChannels(globalConfig) {
   const tg = globalConfig.telegram || {};
@@ -135,15 +136,17 @@ export function resolveChannels(globalConfig) {
       poll_interval_ms: c.poll_interval_ms || tg.poll_interval_ms || 1500,
     }));
   }
-  // Legacy single-channel mode
-  if (!tg.bot_token && !process.env.BOT_TELEGRAM_TOKEN && !process.env.TELEGRAM_BOT_TOKEN) {
+  // Env-only mode: no channels configured, but a token is in the environment.
+  // resolveBotToken()/resolveChatId() fill the blanks from BOT_TELEGRAM_TOKEN
+  // / TELEGRAM_CHAT_ID at call time.
+  if (!process.env.BOT_TELEGRAM_TOKEN && !process.env.TELEGRAM_BOT_TOKEN) {
     return [];
   }
   return [
     {
       name: "default",
-      bot_token: tg.bot_token || "",
-      chat_id: tg.chat_id || "",
+      bot_token: "",
+      chat_id: "",
       route_to_agent: tg.route_to_agent || "",
       project: null,
       respond_with_engine: tg.respond_with_engine !== false,
@@ -155,3 +158,52 @@ export function resolveChannels(globalConfig) {
 export function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
+
+/**
+ * Drop this chat's AbortController only if it is still the one we own.
+ * An aborted turn used to `activeRequests.delete(chat_id)` unconditionally,
+ * which wiped the NEWER turn's controller and made the next interrupt a no-op.
+ */
+export function releaseActiveRequest(activeRequests, chat_id, abortCtrl) {
+  if (chat_id && activeRequests.get(chat_id) === abortCtrl) {
+    activeRequests.delete(chat_id);
+  }
+}
+
+// Below this, a resend of the same text is impatience, not a new instruction.
+// Past it, the run has been going long enough that "again" plausibly means
+// "that is stuck, start over" — so the interrupt goes through as usual.
+const RESEND_WINDOW_MS = 10 * 60_000;
+
+/** Comparable form of a chat message: case, accents and punctuation dropped. */
+function normalizeForResend(text) {
+  return String(text || "")
+    .toLowerCase()
+    .normalize("NFD")
+    .replace(/[\u0300-\u036f]/g, "")
+    .replace(/[^\p{L}\p{N}]+/gu, " ")
+    .trim();
+}
+
+/**
+ * Is this inbound the SAME message the chat is already working on?
+ *
+ * Default Interrupt aborts the running turn on every new message, which is
+ * right for "no, stop, do this instead" and exactly wrong for the case that
+ * actually happens: a long turn goes quiet (one progress note per 90s), the
+ * user assumes it died and sends the same request again. The resend killed the
+ * work in flight and restarted it from zero — so the next one looked stuck too.
+ * Six resends of one message in 35 minutes, and nothing ever finished.
+ *
+ * A verbatim repeat inside the window is treated as "still here?", not as a new
+ * turn: the running work keeps its abort controller and finishes.
+ *
+ * @returns {boolean} true when the caller should let the running turn continue.
+ */
+export function isImpatientResend(prev, text, { now = Date.now } = {}) {
+  if (!prev?.text) return false;
+  const incoming = normalizeForResend(text);
+  if (!incoming) return false;
+  if (incoming !== normalizeForResend(prev.text)) return false;
+  return now() - (prev.startedAt || 0) < RESEND_WINDOW_MS;
+}

package/src/core/channels/telegram/inbound/audio.js

@@ -6,19 +6,22 @@
 //
 // Takes the poller instance (`self`, for logging, channel + the typing
 // indicator) plus the parsed update context, and returns the `text` the rest of
-// the pipeline should run — the transcript merged into any existing caption.
-import { appendGlobalMessage } from "#core/stores/messages.js";
-import { CHANNELS } from "#core/constants/channels.js";
+// the pipeline should run — the transcript merged into any existing caption —
+// plus the `media` metadata dispatch folds into the ONE record it writes for
+// this update. This handler deliberately writes nothing itself: it used to
+// append its own row while also rewriting `text`, so the same turn was stored
+// twice (see dispatch.js).
 import { transcribe as transcribeAudioFile } from "#core/voice/transcription.js";
 import { resolveBotToken, telegramMediaDir } from "../helpers.js";
 import { downloadTelegramFile } from "../media.js";
 
 /**
  * @param {object} self  poller instance (uses self.log, self.channel, self._startTyping)
- * @param {object} ctx   { msg, u, author, chat_id, text, incomingAudio }
- * @returns {Promise<{ text: string }>}  text to continue the pipeline with
+ * @param {object} ctx   { chat_id, text, incomingAudio }
+ * @returns {Promise<{ text: string, media: object }>}  text to continue the
+ *   pipeline with, and what was archived for the inbound record
  */
-export async function handleIncomingAudio(self, { msg, u, author, chat_id, text, incomingAudio }) {
+export async function handleIncomingAudio(self, { chat_id, text, incomingAudio }) {
   const token = resolveBotToken(self.channel);
   const mediaDir = telegramMediaDir();
 
@@ -53,30 +56,23 @@ export async function handleIncomingAudio(self, { msg, u, author, chat_id, text,
     ? `[audio] ${transcript}`
     : `[audio] (transcription unavailable${transcribeError ? ": " + transcribeError : ""})`;
 
-  appendGlobalMessage({
-    channel: CHANNELS.TELEGRAM,
-    direction: "in",
-    type: "audio",
-    actor_id: msg.from?.id ? String(msg.from.id) : author,
-    external_id: String(u.update_id),
-    author,
-    body: audioBody,
-    meta: {
-      chat_id,
-      user_id: msg.from?.id || null,
-      message_id: msg.message_id,
-      tg_channel: self.channel.name,
-      local_path: localPath,
-      file_id: incomingAudio.file_id,
-      duration: incomingAudio.duration,
-      mime_type: incomingAudio.mime_type,
-      transcription_backend: transcribeBackend,
-      transcription_error: transcribeError,
-    },
-  });
-
   // Inject the transcribed text into `text` so the rest of the agent pipeline
   // treats it identically to a typed message. If there was a caption alongside
-  // the audio, prepend the audio marker to it.
-  return { text: text ? `${audioBody}\n${text}` : audioBody };
+  // the audio, prepend the audio marker to it. The file metadata rides back
+  // with it so the stored turn keeps it, download or transcription failures
+  // included.
+  return {
+    text: text ? `${audioBody}\n${text}` : audioBody,
+    media: {
+      kind: "audio",
+      meta: {
+        local_path: localPath,
+        file_id: incomingAudio.file_id,
+        duration: incomingAudio.duration,
+        mime_type: incomingAudio.mime_type,
+        transcription_backend: transcribeBackend,
+        transcription_error: transcribeError,
+      },
+    },
+  };
 }