switchroom 0.15.18 → 0.15.20

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "switchroom",
-  "version": "0.15.18",
+  "version": "0.15.20",
   "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/profiles/_shared/agent-self-service.md.hbs

@@ -38,22 +38,31 @@ tools is to let you do the edit yourself.
   derived from the entry content is assigned.
 
   **Mind the cost — pick the cheapest tier that does the job:**
-  - *Default (no `model`)* — the fire runs as a **full turn in your live
-    session**: your model, your whole context + memory. Right for work that
-    genuinely needs *you* (your persona, your conversation history). Costly for
-    routine checks — every fire pays your full context.
-  - *`model: "sonnet"`* (or `context: "fresh"`) — routes the fire to a **cheap,
-    minimal-context cron session** (Tier 1): a fresh Sonnet with just the
-    prompt, no heavy context. Use for light, self-contained recurring work
-    (summarise a feed, format a digest) where you don't need your memory. Much
-    cheaper per fire. *(Honoured only when the operator has enabled cheap-cron;
-    otherwise it still runs as a normal turn — never silently dropped.)*
+  - *Default (no `model`)* — a **frequent** cron (every ≤60min) is auto-routed
+    to a **cheap, minimal-context cron session** (Tier 1: a fresh Sonnet that
+    still shares your memory + tools but drops your accumulated conversation
+    context). A **daily/weekly** cron defaults to a **full turn in your live
+    session** (Tier 2: your model, your whole context). So routine frequent
+    checks are already cheap without you doing anything.
+  - *`model: "sonnet"` / `context: "fresh"`* — force the cheap Tier-1 session
+    even for a **daily/weekly** self-contained job (summarise a feed, format a
+    digest) — overrides the cadence default. *`context: "agent"`* does the
+    opposite: pins a fire to your full live session when it genuinely needs your
+    accumulated conversation context (this always wins).
+  - *"Post/send a FIXED thing on a schedule"* (a set reminder message, a webhook
+    ping — text fully determined, no thinking) — ask the **operator** for a
+    **`kind: action`**: it runs **model-free, zero tokens** (no session at all),
+    posting your fixed/templated text or firing a fixed request. The cheapest
+    tier there is.
   - *"Only act when X changes"* — don't poll with a frequent prompt cron (every
-    fire is a wasted turn when nothing changed). Ask the **operator** to set up
-    a **poll** (model-free check, e.g. a webpage/API via `kind: poll`) or, for
-    reaction-triggered work, **`reaction_dispatch`** (an emoji reaction wakes
-    you instantly — zero polling). These need an operator config commit
-    (egress/identity gates), so request them rather than authoring them yourself.
+    fire is a wasted turn when nothing changed). Ask the **operator** for a
+    **`kind: poll`** (model-free check, e.g. a webpage/API — only a *change*
+    wakes you) or, for reaction-triggered work, **`reaction_dispatch`** (an
+    emoji reaction wakes you instantly — zero polling).
+  - `kind: action` / `kind: poll` / `reaction_dispatch` need an operator config
+    commit (egress / identity gates), so **request** them rather than authoring
+    them yourself — you can only self-author plain prompt crons (plus the
+    `model`/`context` tier hints).
 
 - **`schedule_remove(name | cron_hash)`** — delete by `name` (the slug from
   add) or by 12-hex `cron_hash` (shown in `cron_list` output). Both

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

@@ -43144,6 +43144,7 @@ var TELEGRAM_MENU_COMMANDS = [
   { command: "logs", description: "Show recent agent logs" },
   { command: "inject", description: "Inject a Claude Code slash command (e.g. /cost)" },
   { command: "model", description: "Show or switch the Claude model" },
+  { command: "effort", description: "Show or switch the reasoning effort" },
   { command: "doctor", description: "Health check (deps, services, MCP)" },
   { command: "usage", description: "Pro/Max plan quota (5h + 7d windows)" },
   { command: "vault", description: "Manage vault secrets + capability grants" },
@@ -43176,6 +43177,7 @@ function switchroomHelpText(agentName3) {
     `<code>/update</code> \u2014 dry-run plan; <code>/update apply</code> \u2014 actually pull images, reconcile, restart`,
     `<code>/restart [name|all]</code> \u2014 bounce agent (drains in-flight turn by default)`,
     `<code>/version</code> \u2014 show versions + running agent health summary`,
+    `<code>/whoami</code> \u2014 this agent's sandbox: tools, MCP, vault key-names, powers`,
     ``,
     `<b>Auth &amp; config</b>`,
     `<code>/auth</code> \u2014 auth status or actions`,
@@ -43185,6 +43187,7 @@ function switchroomHelpText(agentName3) {
     `<code>/auth rm [agent] &lt;slot&gt; [--force]</code> \u2014 remove a slot`,
     `<code>/model</code> \u2014 show the configured Claude model`,
     `<code>/model &lt;name&gt;</code> \u2014 switch the live session's model (opus \u00b7 sonnet \u00b7 haiku or a full id; until restart)`,
+    `<code>/effort</code> \u2014 show or switch reasoning effort (low \u00b7 medium \u00b7 high \u00b7 xhigh \u00b7 max; until restart)`,
     `<code>/topics</code> \u2014 topic-to-agent mappings`,
     `<code>/permissions [agent]</code> \u2014 show agent permissions`,
     `<code>/grant &lt;tool&gt;</code> \u2014 grant a tool permission`,
@@ -44527,6 +44530,7 @@ var INJECT_COMMANDS = new Map([
   ["/hooks", { description: "List configured hooks", expectsOutput: true }],
   ["/memory", { description: "Open memory picker", expectsOutput: true }],
   ["/model", { description: "Open model picker", expectsOutput: true }],
+  ["/effort", { description: "Set reasoning effort", expectsOutput: true }],
   [
     "/clear",
     { description: "Clear session screen", expectsOutput: false }
@@ -44784,6 +44788,7 @@ var INJECT_COMMANDS2 = new Map([
   ["/hooks", { description: "List configured hooks", expectsOutput: true }],
   ["/memory", { description: "Open memory picker", expectsOutput: true }],
   ["/model", { description: "Open model picker", expectsOutput: true }],
+  ["/effort", { description: "Set reasoning effort", expectsOutput: true }],
   [
     "/clear",
     { description: "Clear session screen", expectsOutput: false }
@@ -45392,6 +45397,161 @@ function extractConfirmation(pane) {
   return null;
 }
 
+// gateway/effort-command.ts
+var EFFORT_LEVELS = ["low", "medium", "high", "xhigh", "max"];
+function isValidEffortArg(arg) {
+  return EFFORT_LEVELS.includes(arg.toLowerCase());
+}
+function parseEffortCommand(text) {
+  const m = text.match(/^\/effort(?:@[A-Za-z0-9_]+)?(?:\s+([\s\S]*))?$/);
+  if (!m)
+    return null;
+  const rest = (m[1] ?? "").trim();
+  if (rest.length === 0)
+    return { kind: "show" };
+  const parts = rest.split(/\s+/);
+  if (parts.length > 1) {
+    return { kind: "help", reason: "effort takes a single level" };
+  }
+  const arg = parts[0];
+  if (arg.toLowerCase() === "help")
+    return { kind: "help" };
+  if (!isValidEffortArg(arg)) {
+    return { kind: "help", reason: `not a valid effort level: ${arg}` };
+  }
+  return { kind: "set", level: arg.toLowerCase() };
+}
+var PERSIST_NOTE2 = "<i>Session-only \u2014 reverts to the configured default on restart. To change the default, set <code>thinking_effort:</code> in switchroom.yaml and restart.</i>";
+var LEVELS_INLINE = EFFORT_LEVELS.map((l) => `<code>${l}</code>`).join(" \u00b7 ");
+function helpText3(deps, reason) {
+  const lines = [];
+  if (reason)
+    lines.push(`\u26a0\ufe0f ${deps.escapeHtml(reason)}`);
+  lines.push("<b>/effort</b> \u2014 show or switch the reasoning effort (faster\u2192smarter)", "<code>/effort</code> \u2014 show the configured effort + a tap menu", `<code>/effort &lt;level&gt;</code> \u2014 switch the live session (${LEVELS_INLINE})`, PERSIST_NOTE2);
+  return { text: lines.join(`
+`), html: true };
+}
+async function handleEffortCommand(parsed, deps) {
+  if (parsed.kind === "help")
+    return helpText3(deps, parsed.reason);
+  if (parsed.kind === "show") {
+    const configured = deps.getConfiguredEffort();
+    const shown = configured && configured.length > 0 ? configured : "low";
+    return {
+      text: [
+        `<b>Effort \u2014 ${deps.escapeHtml(deps.getAgentName())}</b>`,
+        `Configured default: <code>${deps.escapeHtml(shown)}</code>`,
+        `Switch the live session: ${EFFORT_LEVELS.map((l) => `<code>/effort ${l}</code>`).join(" \u00b7 ")}`,
+        PERSIST_NOTE2
+      ].join(`
+`),
+      html: true
+    };
+  }
+  if (!isValidEffortArg(parsed.level)) {
+    return helpText3(deps, `not a valid effort level: ${parsed.level}`);
+  }
+  const verbHtml = `<code>/effort ${deps.escapeHtml(parsed.level)}</code>`;
+  let result;
+  try {
+    result = await deps.inject(deps.getAgentName(), `/effort ${parsed.level}`);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return { text: `\u274c ${verbHtml} \u2014 inject failed: ${deps.escapeHtml(msg)}`, html: true };
+  }
+  if (result.outcome === "ok") {
+    return {
+      text: [
+        `${verbHtml}`,
+        deps.preBlock(result.output),
+        ...result.truncated ? ["<i>truncated</i>"] : [],
+        PERSIST_NOTE2
+      ].join(`
+`),
+      html: true
+    };
+  }
+  if (result.outcome === "ok_no_output") {
+    return {
+      text: [
+        `${verbHtml} \u2014 sent, but no response captured. The agent may be mid-turn; check <code>/inject /status</code> to confirm the active effort.`,
+        PERSIST_NOTE2
+      ].join(`
+`),
+      html: true
+    };
+  }
+  if (result.errorCode === "session_missing") {
+    return {
+      text: "\u274c tmux session not found \u2014 the agent must be running under the tmux supervisor (the default). Remove <code>experimental.legacy_pty: true</code> if set.",
+      html: true
+    };
+  }
+  return {
+    text: `\u274c ${verbHtml} \u2014 ${deps.escapeHtml(result.errorMessage ?? "inject failed")}`,
+    html: true
+  };
+}
+var EFFORT_CALLBACK_PREFIX = "eff:";
+var EFFORT_CALLBACK_SELECT = "eff:s:";
+function effortSelectCallbackData(level) {
+  return `${EFFORT_CALLBACK_SELECT}${level}`;
+}
+function menuKeyboard2(highlight) {
+  return [
+    EFFORT_LEVELS.map((l) => ({
+      text: l === highlight ? `\u2705 ${l}` : l,
+      callback_data: effortSelectCallbackData(l)
+    }))
+  ];
+}
+function buildEffortMenu(deps, highlight) {
+  const configured = deps.getConfiguredEffort() || "low";
+  const live = highlight ?? configured;
+  return {
+    text: [
+      `<b>Effort \u2014 ${deps.escapeHtml(deps.getAgentName())}</b>`,
+      `Default: <code>${deps.escapeHtml(configured)}</code> \u00b7 faster \u2192 smarter: ${LEVELS_INLINE}`,
+      "Tap to switch the live session:",
+      PERSIST_NOTE2
+    ].join(`
+`),
+    html: true,
+    keyboard: menuKeyboard2(live)
+  };
+}
+async function handleEffortMenuCallback(data, deps) {
+  if (!data.startsWith(EFFORT_CALLBACK_SELECT)) {
+    return { reply: buildEffortMenu(deps) };
+  }
+  const level = data.slice(EFFORT_CALLBACK_SELECT.length);
+  if (!isValidEffortArg(level)) {
+    return { reply: buildEffortMenu(deps) };
+  }
+  let banner;
+  let selected;
+  try {
+    const result = await deps.inject(deps.getAgentName(), `/effort ${level}`);
+    if (result.outcome === "ok" || result.outcome === "ok_no_output") {
+      banner = `\u2705 Effort \u2192 <code>${deps.escapeHtml(level)}</code> for this session`;
+      selected = level;
+    } else if (result.errorCode === "session_missing") {
+      banner = "\u274c tmux session not found \u2014 is the agent running under the supervisor?";
+    } else {
+      banner = `\u274c couldn't set effort: ${deps.escapeHtml(result.errorMessage ?? "inject failed")}`;
+    }
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    banner = `\u274c inject failed: ${deps.escapeHtml(msg)}`;
+  }
+  const menu = buildEffortMenu(deps, selected);
+  return {
+    reply: { ...menu, text: `${banner}
+${menu.text}` },
+    selectedEffort: selected
+  };
+}
+
 // ../src/config/loader.ts
 init_dist();
 init_zod();
@@ -53487,6 +53647,15 @@ function readBashCommand(inputPreview) {
   }
 }
 
+// gateway/grant-restart.ts
+function grantRestartDecision(opts) {
+  if ((opts.killSwitch ?? "") === "0")
+    return "disabled";
+  if (!opts.selfAgent || opts.selfAgent !== opts.agentName)
+    return "disabled";
+  return opts.turnInFlight ? "deferred" : "now";
+}
+
 // permission-diff.ts
 var TARGET_HEADER_A = "--- a/switchroom.yaml";
 var TARGET_HEADER_B = "+++ b/switchroom.yaml";
@@ -54158,11 +54327,11 @@ function readTurnActiveMarkerAgeMs(stateDir, now) {
 }
 
 // ../src/build-info.ts
-var VERSION = "0.15.18";
-var COMMIT_SHA = "d7c044b9";
-var COMMIT_DATE = "2026-06-14T08:55:07+10:00";
+var VERSION = "0.15.20";
+var COMMIT_SHA = "0b63ab9e";
+var COMMIT_DATE = "2026-06-14T10:58:14+10:00";
 var LATEST_PR = null;
-var COMMITS_AHEAD_OF_TAG = 3;
+var COMMITS_AHEAD_OF_TAG = 5;
 
 // gateway/boot-version.ts
 function formatRelativeAgo(iso) {
@@ -61613,6 +61782,26 @@ async function sweepBeforeSelfRestart() {
 `);
   }
 }
+function scheduleGrantRestart(agentName3, chatId, threadId, reason) {
+  const decision = grantRestartDecision({
+    killSwitch: process.env.SWITCHROOM_AUTORESTART_ON_GRANT,
+    selfAgent: process.env.SWITCHROOM_AGENT_NAME,
+    agentName: agentName3,
+    turnInFlight: turnInFlightForGate()
+  });
+  if (decision === "disabled")
+    return decision;
+  if (chatId != null) {
+    writeRestartMarker({ chat_id: String(chatId), thread_id: threadId ?? null, ack_message_id: null, ts: Date.now() });
+  }
+  stampUserRestartReason(reason);
+  if (decision === "deferred") {
+    pendingRestarts.set(agentName3, Date.now());
+  } else {
+    sweepBeforeSelfRestart().finally(() => triggerSelfRestart(agentName3, reason, 1500));
+  }
+  return decision;
+}
 function formatAuthOutputForTelegram(output) {
   const trimmed = stripAnsi2(output).trim();
   const url = trimmed.match(/https:\/\/\S+/)?.[0] ?? null;
@@ -62143,6 +62332,43 @@ bot.command("model", async (ctx) => {
   const reply = await handleModelCommand(parsed, deps);
   await switchroomReply(ctx, reply.text, { html: reply.html });
 });
+function buildEffortDeps() {
+  return {
+    inject: injectSlashCommand,
+    getAgentName: getMyAgentName,
+    getConfiguredEffort: () => {
+      const data = switchroomExecJson(["agent", "list"]);
+      return data?.agents?.find((a) => a.name === getMyAgentName())?.thinking_effort ?? null;
+    },
+    escapeHtml: escapeHtmlForTg,
+    preBlock
+  };
+}
+function effortMenuReplyMarkup(reply) {
+  if (!reply.keyboard)
+    return;
+  const kb = new import_grammy9.InlineKeyboard;
+  for (const row of reply.keyboard) {
+    for (const btn of row)
+      kb.text(btn.text, btn.callback_data);
+    kb.row();
+  }
+  return kb;
+}
+bot.command("effort", async (ctx) => {
+  if (!isAuthorizedSender(ctx))
+    return;
+  const text = ctx.message?.text ?? ctx.channelPost?.text ?? "";
+  const parsed = parseEffortCommand(text) ?? { kind: "show" };
+  const deps = buildEffortDeps();
+  if (parsed.kind === "show") {
+    const menu = buildEffortMenu(deps);
+    await switchroomReply(ctx, menu.text, { html: true, reply_markup: effortMenuReplyMarkup(menu) });
+    return;
+  }
+  const reply = await handleEffortCommand(parsed, deps);
+  await switchroomReply(ctx, reply.text, { html: reply.html });
+});
 bot.command("agentstart", async (ctx) => {
   if (!isAuthorizedSender(ctx))
     return;
@@ -64855,6 +65081,56 @@ bot.command("version", async (ctx) => {
 ${preBlock(formatSwitchroomOutput(err.message ?? "unknown error"))}`, { html: true });
   }
 });
+bot.command("whoami", async (ctx) => {
+  if (!isAuthorizedSender(ctx))
+    return;
+  try {
+    let raw;
+    try {
+      raw = switchroomExecCombined(["config", "whoami"], 1e4);
+    } catch (err) {
+      raw = err.stdout ?? err.message ?? "whoami failed";
+    }
+    const trimmed = stripAnsi2(raw).trim();
+    let card;
+    try {
+      card = formatWhoamiCard(JSON.parse(trimmed.split(`
+`).pop() ?? trimmed));
+    } catch {
+      card = preBlock(formatSwitchroomOutput(trimmed || "whoami: no output"));
+    }
+    await switchroomReply(ctx, card, { html: true });
+  } catch (err) {
+    await switchroomReply(ctx, `<b>whoami failed:</b>
+${preBlock(formatSwitchroomOutput(err.message ?? "unknown error"))}`, { html: true });
+  }
+});
+function formatWhoamiCard(v) {
+  const esc = escapeHtmlForTg;
+  const yn = (b) => b ? "\u2713" : "\u2717";
+  const lines = [];
+  lines.push(`\uD83D\uDC64 <b>${esc(v.name ?? "?")}</b> \xB7 ${esc(v.tier ?? "standard")}`);
+  if (v.persona)
+    lines.push(esc(v.persona));
+  if (v.model)
+    lines.push(`Model: ${esc(v.model)}`);
+  const allow = v.tools?.allow ?? [];
+  lines.push(`Tools: ${allow.length ? esc(allow.slice(0, 8).join(", ")) + (allow.length > 8 ? ` \u2026(+${allow.length - 8})` : "") : "\u2014"}`);
+  if ((v.tools?.deny ?? []).length)
+    lines.push(`Denied: ${esc(v.tools.deny.join(", "))}`);
+  if ((v.mcpServers ?? []).length)
+    lines.push(`MCP: ${esc(v.mcpServers.join(", "))}`);
+  if ((v.skills ?? []).length)
+    lines.push(`Skills: ${esc(v.skills.join(", "))}`);
+  if ((v.vault ?? []).length) {
+    lines.push(`Vault keys (names only): ${v.vault.map((k) => `${esc(k.key)} ${yn(k.readable)}`).join(", ")}`);
+  }
+  const p = v.powers ?? {};
+  lines.push(`Powers: admin ${yn(p.admin)} \xB7 root ${yn(p.root)} \xB7 config-edit ${yn(p.configEdit)} \xB7 cross-agent verbs ${yn(p.crossAgentHostVerbs)}`);
+  lines.push(`Schedule: ${v.scheduleCount ?? 0} cron \xB7 Memory: ${esc(v.memoryBackend ?? "none")}`);
+  return lines.join(`
+`);
+}
 bot.command("commands", async (ctx) => {
   if (!isAuthorizedSender(ctx))
     return;
@@ -64870,6 +65146,26 @@ bot.on("callback_query:data", async (ctx) => {
     await handleAuthDashboardCallback(ctx);
     return;
   }
+  if (data.startsWith(EFFORT_CALLBACK_PREFIX)) {
+    const access2 = loadAccess();
+    const senderId2 = String(ctx.from?.id ?? "");
+    if (!access2.allowFrom.includes(senderId2)) {
+      await ctx.answerCallbackQuery({ text: "Not authorized." });
+      return;
+    }
+    await ctx.answerCallbackQuery({ text: "Setting effort\u2026" }).catch(() => {});
+    try {
+      const outcome = await handleEffortMenuCallback(data, buildEffortDeps());
+      await ctx.editMessageText(outcome.reply.text, {
+        parse_mode: "HTML",
+        reply_markup: effortMenuReplyMarkup(outcome.reply) ?? { inline_keyboard: [] }
+      }).catch(() => {});
+    } catch (err) {
+      process.stderr.write(`telegram gateway: effort-menu callback failed: ${err?.message ?? String(err)}
+`);
+    }
+    return;
+  }
   if (data.startsWith(MODEL_CALLBACK_PREFIX)) {
     const access2 = loadAccess();
     const senderId2 = String(ctx.from?.id ?? "");
@@ -65299,10 +65595,12 @@ ${preBlock(formatSwitchroomOutput(err.message ?? "unknown error"))}`, { html: tr
     }
     const ok = durable;
     const legacyNote = legacy && durable;
-    const ackText2 = ok ? legacyNote ? `\u2705 Saved. ${agentName3} can now ${grantPhrase} without asking (legacy path).` : `\u2705 Saved. ${agentName3} can now ${grantPhrase} without asking.` : editLockHint ? `\u26A0\uFE0F Allowed for now \u2014 config edits are locked. Enable hostd.config_edit_enabled.` : `\u26A0\uFE0F Allowed for now, but "always" did NOT save \u2014 it will ask again after restart. Check gateway log.`;
+    const restartScheduled = ok && !legacy && scheduleGrantRestart(agentName3, ctx.chat?.id, ctx.callbackQuery?.message?.message_thread_id, `always-allow: ${grantPhrase}`) !== "disabled";
+    const liveSuffix = restartScheduled ? " \u2014 applying now (restarting to take effect)" : "";
+    const ackText2 = ok ? legacyNote ? `\u2705 Saved. ${agentName3} can now ${grantPhrase} without asking (legacy path).` : `\u2705 Saved. ${agentName3} can now ${grantPhrase} without asking.${liveSuffix}` : editLockHint ? `\u26A0\uFE0F Allowed for now \u2014 config edits are locked. Enable hostd.config_edit_enabled.` : `\u26A0\uFE0F Allowed for now, but "always" did NOT save \u2014 it will ask again after restart. Check gateway log.`;
     const sourceMsg = ctx.callbackQuery?.message;
     const baseText2 = sourceMsg && "text" in sourceMsg && sourceMsg.text ? escapeHtmlForTg(sourceMsg.text) : "";
-    const editLabel = ok ? legacyNote ? `\u2705 <b>${escapeHtmlForTg(agentName3)} can now ${escapeHtmlForTg(grantPhrase)}</b> without asking (legacy path); restart agent for full effect` : `\u2705 <b>${escapeHtmlForTg(agentName3)} can now ${escapeHtmlForTg(grantPhrase)}</b> without asking; restart agent for full effect` : editLockHint ? `\u26A0\uFE0F <b>Allowed for now \u2014 "always" did NOT save.</b> Config edits are locked; enable <code>hostd.config_edit_enabled</code>.` : `\u26A0\uFE0F <b>Allowed for now \u2014 "always" did NOT save.</b> It will ask again after restart. Check gateway log.`;
+    const editLabel = ok ? legacyNote ? `\u2705 <b>${escapeHtmlForTg(agentName3)} can now ${escapeHtmlForTg(grantPhrase)}</b> without asking (legacy path); restart agent for full effect` : restartScheduled ? `\u2705 <b>${escapeHtmlForTg(agentName3)} can now ${escapeHtmlForTg(grantPhrase)}</b> without asking \u2014 applying now (restarting to take effect).` : `\u2705 <b>${escapeHtmlForTg(agentName3)} can now ${escapeHtmlForTg(grantPhrase)}</b> without asking; restart agent for full effect` : editLockHint ? `\u26A0\uFE0F <b>Allowed for now \u2014 "always" did NOT save.</b> Config edits are locked; enable <code>hostd.config_edit_enabled</code>.` : `\u26A0\uFE0F <b>Allowed for now \u2014 "always" did NOT save.</b> It will ask again after restart. Check gateway log.`;
     await finalizeCallback(ctx, {
       ackText: ackText2.slice(0, 200),
       newText: baseText2 ? `${baseText2}