switchroom 0.19.40 → 0.19.41

package/dist/cli/switchroom.js

@@ -2120,7 +2120,7 @@ var init_esm = __esm(() => {
 });
 
 // src/build-info.ts
-var VERSION = "0.19.40", COMMIT_SHA = "89286b22";
+var VERSION = "0.19.41", COMMIT_SHA = "e77ee9c0";
 
 // src/cli/resolve-version.ts
 import { existsSync, readFileSync } from "node:fs";
@@ -70125,6 +70125,9 @@ var init_server4 = __esm(() => {
   ];
 });
 
+// telegram-plugin/gateway/turn-record-status.ts
+var ROUTE_FIELD_SHIP_TS = 1785456000;
+
 // src/fleet-health/detect.ts
 function parseTurns(text) {
   const out = [];
@@ -70160,12 +70163,14 @@ function isoFromTs(ts) {
 function detectTurnFindings(agent, turns, opts = {}) {
   const findings = [];
   const silentNoopFloorTs = opts.silentNoopFloorTs ?? SILENT_NOOP_FLOOR_TS;
+  const routeFieldShipTs = opts.routeFieldShipTs ?? ROUTE_FIELD_SHIP_TS;
   for (const t of ownedTurns(agent, turns)) {
     const tid = typeof t.turn_id === "string" ? t.turn_id : "?";
     const st = t.status;
     const tl = typeof t.tools === "number" ? t.tools : 0;
     const dur = typeof t.duration_ms === "number" ? t.duration_ms : 0;
     const synthetic = tid.includes("synthetic-");
+    const route = typeof t.route === "string" ? t.route : undefined;
     const ts = isoFromTs(t.ts);
     if (st === "send_failed") {
       findings.push({
@@ -70194,13 +70199,33 @@ function detectTurnFindings(agent, turns, opts = {}) {
       });
     }
     if (st === "complete" && tl === 0 && !synthetic && t.ts != null && t.ts >= silentNoopFloorTs) {
-      findings.push({
-        signal: "silent-no-op-candidate",
-        agent,
-        turn_id: tid,
-        log_pointer: `turns.jsonl:${tid} tools=0`,
-        ts
-      });
+      if (route === "flush") {
+        findings.push({
+          signal: "flush-recovered-turn",
+          agent,
+          turn_id: tid,
+          log_pointer: `turns.jsonl:${tid} tools=0 route=flush`,
+          ts
+        });
+      } else if (route === "reply" || route === "stream") {} else if (route === "none") {
+        findings.push({
+          signal: "silent-no-op-candidate",
+          agent,
+          turn_id: tid,
+          log_pointer: `turns.jsonl:${tid} tools=0 route=none`,
+          ts
+        });
+      } else {
+        if (t.ts >= routeFieldShipTs) {
+          findings.push({
+            signal: "silent-no-op-candidate",
+            agent,
+            turn_id: tid,
+            log_pointer: `turns.jsonl:${tid} tools=0`,
+            ts
+          });
+        }
+      }
     }
   }
   return findings;
@@ -70314,6 +70339,12 @@ var init_mapping = __esm(() => {
       job_spec: "know-what-my-agent-is-doing",
       signature: "silent-no-op:completed-zero-tools"
     },
+    "flush-recovered-turn": {
+      failure_mode: "drift",
+      severity: 1,
+      job_spec: "know-what-my-agent-is-doing",
+      signature: "flush-recovered:completed-zero-tools-route-flush"
+    },
     "duplicate-delivery-represent": {
       failure_mode: "duplicate",
       severity: 2,

package/dist/host-control/main.js

@@ -21010,6 +21010,7 @@ function parsePendingRolloutMarker(raw) {
   if (o.allow_downgrade !== undefined && typeof o.allow_downgrade !== "boolean") {
     return null;
   }
+  const narrationIdValid = typeof o.narration_message_id === "number" && Number.isInteger(o.narration_message_id) && o.narration_message_id > 0;
   return {
     v: 1,
     request_id: o.request_id,
@@ -21017,6 +21018,7 @@ function parsePendingRolloutMarker(raw) {
     ...o.agents !== undefined ? { agents: o.agents } : {},
     ...o.skip_web !== undefined ? { skip_web: o.skip_web } : {},
     ...o.allow_downgrade !== undefined ? { allow_downgrade: o.allow_downgrade } : {},
+    ...narrationIdValid ? { narration_message_id: o.narration_message_id } : {},
     caller: caller.kind === "agent" ? { kind: "agent", name: caller.name } : { kind: "operator" },
     created_at: o.created_at,
     prior_hostd_version: o.prior_hostd_version
@@ -21320,7 +21322,7 @@ function allocateAgentUid(name) {
 }
 
 // src/build-info.ts
-var VERSION = "0.19.40";
+var VERSION = "0.19.41";
 
 // src/setup/hindsight-recall-tunables.ts
 var RECALL_DEADLINE_HEADROOM_SECONDS = 2;
@@ -30786,6 +30788,27 @@ class HostdServer {
       })
     };
   }
+  persistNarrationMessageId(requestId, messageId) {
+    try {
+      if (!Number.isInteger(messageId) || messageId <= 0)
+        return;
+      const markerPath = join13(this.hostdDirPath(), SELF_BUMP_MARKER_FILENAME);
+      if (!existsSync15(markerPath))
+        return;
+      const marker = parsePendingRolloutMarker(readFileSync11(markerPath, "utf8"));
+      if (!marker)
+        return;
+      if (marker.request_id !== requestId)
+        return;
+      const updated = {
+        ...marker,
+        narration_message_id: messageId
+      };
+      const tmp = `${markerPath}.tmp`;
+      writeFileSync6(tmp, encodePendingRolloutMarker(updated), { mode: 384 });
+      renameSync5(tmp, markerPath);
+    } catch {}
+  }
   async resumePendingSelfBumpRollout() {
     const markerPath = join13(this.hostdDirPath(), SELF_BUMP_MARKER_FILENAME);
     if (!existsSync15(markerPath))
@@ -30854,6 +30877,9 @@ class HostdServer {
       ...marker.skip_web ? { skip_web: true } : {},
       ...marker.allow_downgrade ? { allow_downgrade: true } : {}
     }, marker.request_id, caller, Date.now());
+    if (marker.narration_message_id !== undefined && caller.kind === "agent") {
+      this.rolloutNarrator?.seedPostedMessage?.(marker.request_id, caller.name, marker.narration_message_id);
+    }
     this.onRolloutPhase(entry, { phase: "self-bump-done", target: marker.pin });
   }
   async handleAgentStart(req, started) {
@@ -32672,28 +32698,49 @@ class LogTailRolloutNarrator {
       }
     }
   }
+  freshState(agentName, target) {
+    return {
+      agentName,
+      lastAppliedSeq: -1,
+      messageId: null,
+      posting: false,
+      postAttempts: 0,
+      postFailed: false,
+      render: { target },
+      agents: [],
+      singletons: initialSingletons(),
+      frozen: false,
+      timer: null,
+      pendingEditAfterPost: false
+    };
+  }
   ensureState(entry) {
     let st = this.states.get(entry.request_id);
     if (!st) {
       const agentName = entry.caller.kind === "agent" ? entry.caller.name : "";
-      st = {
-        agentName,
-        lastAppliedSeq: -1,
-        messageId: null,
-        posting: false,
-        postAttempts: 0,
-        postFailed: false,
-        render: { target: entry.pin ?? "" },
-        agents: [],
-        singletons: initialSingletons(),
-        frozen: false,
-        timer: null,
-        pendingEditAfterPost: false
-      };
+      st = this.freshState(agentName, entry.pin ?? "");
       this.states.set(entry.request_id, st);
     }
     return st;
   }
+  seedPostedMessage(requestId, agentName, messageId) {
+    const existing = this.states.get(requestId);
+    if (existing) {
+      if (existing.messageId === null) {
+        existing.messageId = messageId;
+        existing.posting = false;
+        existing.postFailed = false;
+        if (existing.postAttempts < 1)
+          existing.postAttempts = 1;
+        existing.pendingEditAfterPost = false;
+      }
+      return;
+    }
+    const st = this.freshState(agentName, "");
+    st.messageId = messageId;
+    st.postAttempts = 1;
+    this.states.set(requestId, st);
+  }
   scheduleRenderOrPost(requestId) {
     const st = this.states.get(requestId);
     if (!st)
@@ -32734,6 +32781,11 @@ class LogTailRolloutNarrator {
       }
       st.messageId = mid;
       st.postFailed = false;
+      try {
+        this.opts.onMessageId?.(requestId, mid);
+      } catch (e) {
+        this.opts.log?.(`onMessageId sink threw (non-fatal): ${e.message}`);
+      }
       if (st.pendingEditAfterPost) {
         st.pendingEditAfterPost = false;
         this.flush(requestId, false);
@@ -33378,8 +33430,11 @@ async function main() {
     resolveGatewaySocket,
     log: (m) => process.stderr.write(`hostd: rollout-narration — ${m}
 `)
-  }), { log: (m) => process.stderr.write(`hostd: rollout-narration — ${m}
-`) });
+  }), {
+    log: (m) => process.stderr.write(`hostd: rollout-narration — ${m}
+`),
+    onMessageId: (rid, mid) => server?.persistNarrationMessageId(rid, mid)
+  });
   const server = new HostdServer({
     homeDir: homedir8(),
     agentUids,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "switchroom",
   "//version": "NOT the release version — source of truth is the git tag, resolved by scripts/build.mjs:resolveVersion() (see CLAUDE.md > Standard release process). This field is stale by design and only the Layer-4 dev/non-tag fallback for build.mjs + src/cli/resolve-version.ts; do NOT bump it expecting a release to pick it up. npm-pack tarball naming needs a real version — do that as an UNCOMMITTED pack-time bump (see release step 6), never a committed one.",
-  "version": "0.19.40",
+  "version": "0.19.41",
   "description": "Run Claude Code 24/7 on your Claude Pro/Max subscription over Telegram. Open-source alternative to OpenClaw and NanoClaw — no API keys.",
   "type": "module",
   "bin": {

package/telegram-plugin/bridge/bridge.ts

@@ -268,7 +268,7 @@ const TOOL_SCHEMAS = [
   {
     name: 'send_checklist',
     description:
-      'Send a native Telegram checklist (interactive task list) to a chat. Users can tick tasks directly in the Telegram app. Returns the message_id of the created checklist. The bot is notified when tasks are ticked — these arrive as channel events with kind="checklist_task_changed". Limit: 30 tasks per checklist.',
+      'Send a checklist (task list) to a chat. Native interactive Telegram checklists require a Business-account connection, which most deployments do not have — in that normal case the checklist is sent as a formatted TEXT message (bold title + ✅/⬜ task lines) and the result carries degraded:"text": tasks are NOT tappable, and you tick them yourself via update_checklist (task ids are 1..N in send order). With a Business connection configured, the checklist is sent natively and tick events arrive as channel events with kind="checklist_task_changed". Returns JSON with message_id and mode. Limit: 30 tasks.',
     inputSchema: {
       type: 'object',
       properties: {
@@ -357,7 +357,7 @@ const TOOL_SCHEMAS = [
   {
     name: 'update_checklist',
     description:
-      'Patch an existing native Telegram checklist. Supports updating the title, adding new tasks, removing tasks, or marking tasks done/undone. Tasks with an id target existing items; tasks without an id are appended. Preserves existing task ids across edits.',
+      'Patch a checklist previously sent with send_checklist: update the title, append tasks, or mark tasks done/undone. Tasks with an id target existing items (ids are 1..N in send order for text-mode checklists); tasks without an id are appended. Removal is not supported. The edit re-renders in the mode the checklist was sent in (text for most deployments). Returns JSON { ok, ... }; after a gateway restart the stored task state may be gone — then it returns ok:false with reason "unknown_checklist" unless you pass a full replacement (title + every task\'s text).',
     inputSchema: {
       type: 'object',
       properties: {

package/telegram-plugin/dist/bridge/bridge.js

@@ -25241,7 +25241,7 @@ var TOOL_SCHEMAS = [
   },
   {
     name: "send_checklist",
-    description: 'Send a native Telegram checklist (interactive task list) to a chat. Users can tick tasks directly in the Telegram app. Returns the message_id of the created checklist. The bot is notified when tasks are ticked \u2014 these arrive as channel events with kind="checklist_task_changed". Limit: 30 tasks per checklist.',
+    description: 'Send a checklist (task list) to a chat. Native interactive Telegram checklists require a Business-account connection, which most deployments do not have \u2014 in that normal case the checklist is sent as a formatted TEXT message (bold title + \u2705/\u2B1C task lines) and the result carries degraded:"text": tasks are NOT tappable, and you tick them yourself via update_checklist (task ids are 1..N in send order). With a Business connection configured, the checklist is sent natively and tick events arrive as channel events with kind="checklist_task_changed". Returns JSON with message_id and mode. Limit: 30 tasks.',
     inputSchema: {
       type: "object",
       properties: {
@@ -25326,7 +25326,7 @@ var TOOL_SCHEMAS = [
   },
   {
     name: "update_checklist",
-    description: "Patch an existing native Telegram checklist. Supports updating the title, adding new tasks, removing tasks, or marking tasks done/undone. Tasks with an id target existing items; tasks without an id are appended. Preserves existing task ids across edits.",
+    description: `Patch a checklist previously sent with send_checklist: update the title, append tasks, or mark tasks done/undone. Tasks with an id target existing items (ids are 1..N in send order for text-mode checklists); tasks without an id are appended. Removal is not supported. The edit re-renders in the mode the checklist was sent in (text for most deployments). Returns JSON { ok, ... }; after a gateway restart the stored task state may be gone \u2014 then it returns ok:false with reason "unknown_checklist" unless you pass a full replacement (title + every task's text).`,
     inputSchema: {
       type: "object",
       properties: {

package/telegram-plugin/dist/gateway/gateway.js

@@ -39504,6 +39504,178 @@ function redactChecklistFields(title, tasks, redact) {
   };
 }
 
+// gateway/checklist-fallback.ts
+var CHECKLIST_MAX_TASKS = 30;
+function buildChecklistTasks(tasks) {
+  if (tasks.length > CHECKLIST_MAX_TASKS) {
+    throw new Error(`checklist exceeds ${CHECKLIST_MAX_TASKS}-task limit (got ${tasks.length})`);
+  }
+  return tasks.map((t, i) => ({ id: i + 1, text: t.text, done: t.done === true }));
+}
+function renderChecklistText(cl, opts) {
+  const header = opts?.literal ? cl.title : `**${cl.title}**`;
+  const lines = cl.tasks.map((t) => `${t.done ? "\u2705" : "\u2b1c"} ${t.text}`);
+  return [header, ...lines].join(`
+`);
+}
+function applyChecklistPatch(cl, patch) {
+  const tasks = cl.tasks.map((t) => ({ ...t }));
+  for (const p of patch.tasks ?? []) {
+    const pid = p.id != null ? Number(p.id) : undefined;
+    const existing = pid != null ? tasks.find((t) => t.id === pid) : undefined;
+    if (existing) {
+      if (p.text != null)
+        existing.text = p.text;
+      if (p.done != null)
+        existing.done = p.done;
+    } else {
+      const nextId = pid != null && Number.isFinite(pid) ? pid : tasks.reduce((m, t) => Math.max(m, t.id), 0) + 1;
+      tasks.push({ id: nextId, text: p.text ?? "", done: p.done === true });
+    }
+  }
+  if (tasks.length > CHECKLIST_MAX_TASKS) {
+    throw new Error(`checklist exceeds ${CHECKLIST_MAX_TASKS}-task limit (got ${tasks.length})`);
+  }
+  return { title: patch.title ?? cl.title, tasks };
+}
+function buildNativeChecklistPayload(p) {
+  return {
+    business_connection_id: p.businessConnectionId,
+    chat_id: p.chatId,
+    checklist: {
+      title: p.title,
+      tasks: p.tasks.map((t) => ({ id: t.id, text: t.text }))
+    },
+    ...p.replyToMessageId != null ? { reply_parameters: { message_id: p.replyToMessageId } } : {},
+    ...p.protectContent === true ? { protect_content: true } : {}
+  };
+}
+function buildNativeEditChecklistPayload(p) {
+  return {
+    business_connection_id: p.businessConnectionId,
+    chat_id: p.chatId,
+    message_id: p.messageId,
+    checklist: {
+      title: p.title,
+      tasks: p.tasks.map((t) => ({ id: t.id, text: t.text }))
+    }
+  };
+}
+function createChecklistStore(cap = 500) {
+  const map = new Map;
+  return {
+    get: (key) => map.get(key),
+    set: (key, state) => {
+      if (map.has(key))
+        map.delete(key);
+      map.set(key, state);
+      while (map.size > cap) {
+        const oldest = map.keys().next().value;
+        if (oldest == null)
+          break;
+        map.delete(oldest);
+      }
+    }
+  };
+}
+function checklistStoreKey(chatId, messageId) {
+  return `${chatId}:${messageId}`;
+}
+async function performSendChecklist(deps, args) {
+  const tasks = buildChecklistTasks(args.tasks);
+  if (deps.nativeAvailable && deps.businessConnectionId) {
+    try {
+      const sent2 = await deps.sendNative(buildNativeChecklistPayload({
+        businessConnectionId: deps.businessConnectionId,
+        chatId: args.chatId,
+        title: args.title,
+        tasks,
+        replyToMessageId: args.replyToMessageId,
+        protectContent: args.protectContent
+      }));
+      return {
+        message_id: sent2.message_id,
+        mode: "native",
+        state: { title: args.title, tasks, mode: "native" }
+      };
+    } catch (err) {
+      deps.log(`native sendChecklist failed \u2014 falling back to text render: ${err}
+`);
+    }
+  }
+  const text = renderChecklistText({ title: args.title, tasks }, { literal: deps.literalText });
+  const sent = await deps.sendText(text);
+  return {
+    message_id: sent.message_id,
+    mode: "text",
+    state: { title: args.title, tasks, mode: "text" }
+  };
+}
+function sendChecklistToolText(r) {
+  return JSON.stringify(r.mode === "native" ? { ok: true, message_id: r.message_id, mode: "native" } : {
+    ok: true,
+    message_id: r.message_id,
+    mode: "text",
+    degraded: "text",
+    note: "rendered as a formatted text message (native Telegram checklists require a Business connection) \u2014 tasks are not tappable; use update_checklist with task ids 1..N to tick them"
+  });
+}
+async function performUpdateChecklist(deps, patch) {
+  let base = deps.state;
+  if (!base) {
+    const fullReplacement = patch.title != null && (patch.tasks?.length ?? 0) > 0 && (patch.tasks ?? []).every((t) => t.text != null);
+    if (!fullReplacement) {
+      return {
+        ok: false,
+        reason: "unknown_checklist",
+        hint: "no stored state for this checklist (gateway restarted?). Re-send it with send_checklist, or pass a full replacement (title + every task's text) to update_checklist."
+      };
+    }
+    base = { title: patch.title, tasks: [], mode: "text" };
+  }
+  let next;
+  try {
+    next = applyChecklistPatch(base, patch);
+  } catch (err) {
+    return { ok: false, reason: "edit_failed", hint: String(err) };
+  }
+  const state = { title: next.title, tasks: next.tasks, mode: base.mode };
+  if (base.mode === "native") {
+    if (!deps.nativeAvailable || !deps.businessConnectionId) {
+      return {
+        ok: false,
+        reason: "edit_failed",
+        hint: "this checklist was sent natively but the business connection / checklist API is no longer available."
+      };
+    }
+    try {
+      await deps.editNative(buildNativeEditChecklistPayload({
+        businessConnectionId: deps.businessConnectionId,
+        chatId: deps.chatId,
+        messageId: deps.messageId,
+        title: state.title,
+        tasks: state.tasks
+      }));
+      return { ok: true, mode: "native", state };
+    } catch (err) {
+      deps.log(`native editMessageChecklist failed: ${err}
+`);
+      return { ok: false, reason: "edit_failed", hint: String(err) };
+    }
+  }
+  try {
+    await deps.editText(renderChecklistText(state, { literal: deps.literalText }));
+    return { ok: true, mode: "text", state };
+  } catch (err) {
+    deps.log(`checklist text edit failed: ${err}
+`);
+    return { ok: false, reason: "edit_failed", hint: String(err) };
+  }
+}
+function updateChecklistToolText(r, messageId) {
+  return JSON.stringify(r.ok ? { ok: true, message_id: messageId, mode: r.mode, ...r.mode === "text" ? { degraded: "text" } : {} } : { ok: false, reason: r.reason, hint: r.hint });
+}
+
 // interrupt-marker.ts
 function parseInterruptMarker(text) {
   const trimmed = text.trimStart();
@@ -91772,6 +91944,18 @@ function computeTurnStatus(turn) {
       return turn.finalAnswerDelivered ? "complete" : "no_reply";
   }
 }
+function computeTurnRoute(turn) {
+  switch (turn.deliveryOutcome) {
+    case "failed":
+      return "none";
+    case "delivered":
+      return "flush";
+    case "suppressed":
+      return "reply";
+    default:
+      return turn.finalAnswerDelivered ? turn.replyCalled ? "reply" : "stream" : "none";
+  }
+}
 function buildTurnRecord(turn, endedAt) {
   return {
     ts: Math.floor(endedAt / 1000),
@@ -91780,6 +91964,11 @@ function buildTurnRecord(turn, endedAt) {
     tools: turn.toolCallCount ?? 0,
     status: computeTurnStatus(turn),
     turn_id: turn.turnId,
+    route: computeTurnRoute({
+      finalAnswerDelivered: turn.finalAnswerDelivered,
+      replyCalled: turn.replyCalled ?? false,
+      deliveryOutcome: turn.deliveryOutcome
+    }),
     ...turn.landedUnconfirmed != null && turn.landedUnconfirmed > 0 ? { landed_unconfirmed: turn.landedUnconfirmed } : {}
   };
 }
@@ -99917,10 +100106,10 @@ function startOutboxSweep(deps) {
 }
 
 // ../src/build-info.ts
-var VERSION2 = "0.19.40";
-var COMMIT_SHA = "89286b22";
-var COMMIT_DATE = "2026-07-31T04:28:56Z";
-var LATEST_PR = 4061;
+var VERSION2 = "0.19.41";
+var COMMIT_SHA = "e77ee9c0";
+var COMMIT_DATE = "2026-07-31T09:46:10Z";
+var LATEST_PR = 4066;
 var COMMITS_AHEAD_OF_TAG = 0;
 
 // gateway/boot-version.ts
@@ -101975,40 +102164,21 @@ var GRAMMY_VERSION = (() => {
 var _rawSendChecklist;
 var _rawEditMessageChecklist;
 var CHECKLIST_API_AVAILABLE = false;
-async function rawSendChecklist(args) {
-  if (!CHECKLIST_API_AVAILABLE) {
+async function rawSendChecklist(payload) {
+  if (!CHECKLIST_API_AVAILABLE)
     throw new Error("sendChecklist is not available in this grammY/Telegram Bot API version");
-  }
-  const MAX_TASKS = 30;
-  if (args.tasks.length > MAX_TASKS) {
-    throw new Error(`checklist exceeds ${MAX_TASKS}-task limit (got ${args.tasks.length})`);
-  }
-  const result = await _rawSendChecklist({
-    chat_id: Number(args.chat_id),
-    title: args.title,
-    tasks: args.tasks.map((t) => ({ text: t.text, ...t.done != null ? { is_completed: t.done } : {} })),
-    ...args.message_thread_id != null ? { message_thread_id: args.message_thread_id } : {},
-    ...args.reply_to_message_id != null ? { reply_to_message_id: args.reply_to_message_id } : {},
-    ...args.protect_content === true ? { protect_content: true } : {}
-  });
+  const result = await _rawSendChecklist(payload);
   return { message_id: result.message_id };
 }
-async function rawEditMessageChecklist(args) {
-  if (!CHECKLIST_API_AVAILABLE) {
+async function rawEditMessageChecklist(payload) {
+  if (!CHECKLIST_API_AVAILABLE)
     throw new Error("editMessageChecklist is not available in this grammY/Telegram Bot API version");
-  }
-  await _rawEditMessageChecklist({
-    chat_id: Number(args.chat_id),
-    message_id: Number(args.message_id),
-    ...args.title != null ? { title: args.title } : {},
-    ...args.tasks != null ? {
-      tasks: args.tasks.map((t) => ({
-        ...t.id != null ? { id: Number(t.id) } : {},
-        ...t.text != null ? { text: t.text } : {},
-        ...t.done != null ? { is_completed: t.done } : {}
-      }))
-    } : {}
-  });
+  await _rawEditMessageChecklist(payload);
+}
+var checklistStore = createChecklistStore();
+function resolveBusinessConnectionId() {
+  const v = process.env.SWITCHROOM_TELEGRAM_BUSINESS_CONNECTION_ID?.trim();
+  return v ? v : undefined;
 }
 var chatLock = createChatLock();
 var lockedBot;
@@ -103399,6 +103569,7 @@ function emitTurnRecord(turn, endedAt) {
       toolCallCount: turn.toolCallCount ?? 0,
       turnId: turn.turnId,
       finalAnswerDelivered: turn.finalAnswerDelivered,
+      replyCalled: turn.replyCalled,
       deliveryOutcome: turn.deliveryOutcome,
       landedUnconfirmed: turn.landedUnconfirmed
     }, endedAt)) + `
@@ -106723,17 +106894,24 @@ async function executeSendChecklist(args) {
   const protectContent = args.protect_content === true;
   assertAllowedChat(chat_id);
   const { title: redactedTitle, tasks: redactedTasks } = redactChecklistFields(title, tasks, (t) => redactOutboundText(t, "send_checklist"));
-  const sent = await rawSendChecklist({
-    chat_id,
-    title: redactedTitle,
-    tasks: redactedTasks,
+  const literal = (loadAccess().parseMode ?? "html") === "text";
+  const sendOpts = {
     ...threadId != null ? { message_thread_id: threadId } : {},
-    ...replyTo != null ? { reply_to_message_id: replyTo } : {},
+    ...replyTo != null ? { reply_parameters: { message_id: replyTo } } : {},
     ...protectContent ? { protect_content: true } : {}
-  });
-  process.stderr.write(`telegram gateway: send_checklist: sent chatId=${chat_id} messageId=${sent.message_id} tasks=${tasks.length}
+  };
+  const result = await performSendChecklist({
+    businessConnectionId: resolveBusinessConnectionId(),
+    nativeAvailable: CHECKLIST_API_AVAILABLE,
+    sendNative: rawSendChecklist,
+    sendText: (text5) => robustApiCall(() => literal ? lockedBot.api.sendMessage(chat_id, text5, sendOpts) : lockedBot.api.sendRichMessage(chat_id, richMessage2(text5), sendOpts), { verb: "sendMessage", chat_id, threadId }),
+    literalText: literal,
+    log: (l) => process.stderr.write(`telegram gateway: ${l}`)
+  }, { title: redactedTitle, tasks: redactedTasks, chatId: Number(chat_id), replyToMessageId: replyTo, protectContent });
+  checklistStore.set(checklistStoreKey(chat_id, result.message_id), result.state);
+  process.stderr.write(`telegram gateway: send_checklist: sent chatId=${chat_id} messageId=${result.message_id} tasks=${tasks.length} mode=${result.mode}
 `);
-  return { content: [{ type: "text", text: `checklist sent (id: ${sent.message_id})` }] };
+  return { content: [{ type: "text", text: sendChecklistToolText(result) }] };
 }
 var linearAuthAlertLast = new Map;
 var LINEAR_AUTH_ALERT_COOLDOWN_MS = 21600000;
@@ -106785,10 +106963,26 @@ async function executeUpdateChecklist(args) {
   const tasks = args.tasks;
   assertAllowedChat(chat_id);
   const { title: redactedTitle, tasks: redactedTasks } = redactChecklistFields(title, tasks, (t) => redactOutboundText(t, "update_checklist"));
-  await rawEditMessageChecklist({ chat_id, message_id, title: redactedTitle, tasks: redactedTasks });
-  process.stderr.write(`telegram gateway: update_checklist: updated chatId=${chat_id} messageId=${message_id}
-`);
-  return { content: [{ type: "text", text: `checklist updated (id: ${message_id})` }] };
+  const literal = (loadAccess().parseMode ?? "html") === "text";
+  const key = checklistStoreKey(chat_id, message_id);
+  const result = await performUpdateChecklist({
+    state: checklistStore.get(key),
+    businessConnectionId: resolveBusinessConnectionId(),
+    nativeAvailable: CHECKLIST_API_AVAILABLE,
+    editNative: rawEditMessageChecklist,
+    editText: async (text5) => {
+      await robustApiCall(() => lockedBot.api.editMessageText(chat_id, Number(message_id), literal ? text5 : richMessage2(text5)));
+    },
+    literalText: literal,
+    log: (l) => process.stderr.write(`telegram gateway: ${l}`),
+    chatId: Number(chat_id),
+    messageId: Number(message_id)
+  }, { title: redactedTitle, tasks: redactedTasks });
+  if (result.ok)
+    checklistStore.set(key, result.state);
+  process.stderr.write(`telegram gateway: update_checklist: ${result.ok ? `updated mode=${result.mode}` : `failed reason=${result.reason}`} chatId=${chat_id} messageId=${message_id}
+`);
+  return { content: [{ type: "text", text: updateChecklistToolText(result, Number(message_id)) }] };
 }
 function redactOutboundText(text5, site) {
   const masked = redact2(text5);

package/telegram-plugin/dist/server.js

@@ -25007,7 +25007,7 @@ var init_bridge = __esm(async () => {
     },
     {
       name: "send_checklist",
-      description: 'Send a native Telegram checklist (interactive task list) to a chat. Users can tick tasks directly in the Telegram app. Returns the message_id of the created checklist. The bot is notified when tasks are ticked \u2014 these arrive as channel events with kind="checklist_task_changed". Limit: 30 tasks per checklist.',
+      description: 'Send a checklist (task list) to a chat. Native interactive Telegram checklists require a Business-account connection, which most deployments do not have \u2014 in that normal case the checklist is sent as a formatted TEXT message (bold title + \u2705/\u2b1c task lines) and the result carries degraded:"text": tasks are NOT tappable, and you tick them yourself via update_checklist (task ids are 1..N in send order). With a Business connection configured, the checklist is sent natively and tick events arrive as channel events with kind="checklist_task_changed". Returns JSON with message_id and mode. Limit: 30 tasks.',
       inputSchema: {
         type: "object",
         properties: {
@@ -25092,7 +25092,7 @@ var init_bridge = __esm(async () => {
     },
     {
       name: "update_checklist",
-      description: "Patch an existing native Telegram checklist. Supports updating the title, adding new tasks, removing tasks, or marking tasks done/undone. Tasks with an id target existing items; tasks without an id are appended. Preserves existing task ids across edits.",
+      description: `Patch a checklist previously sent with send_checklist: update the title, append tasks, or mark tasks done/undone. Tasks with an id target existing items (ids are 1..N in send order for text-mode checklists); tasks without an id are appended. Removal is not supported. The edit re-renders in the mode the checklist was sent in (text for most deployments). Returns JSON { ok, ... }; after a gateway restart the stored task state may be gone \u2014 then it returns ok:false with reason "unknown_checklist" unless you pass a full replacement (title + every task's text).`,
       inputSchema: {
         type: "object",
         properties: {