switchroom 0.15.19 → 0.15.21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "switchroom",
-  "version": "0.15.19",
+  "version": "0.15.21",
   "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

@@ -43177,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`,
@@ -45453,43 +45454,32 @@ async function handleEffortCommand(parsed, deps) {
   const verbHtml = `<code>/effort ${deps.escapeHtml(parsed.level)}</code>`;
   let result;
   try {
-    result = await deps.inject(deps.getAgentName(), `/effort ${parsed.level}`);
+    result = await deps.applyEffort(deps.getAgentName(), 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 };
+    return { text: `\u274c ${verbHtml} \u2014 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
-    };
+  return { text: applyResultText(parsed.level, result, deps), html: true };
+}
+function applyResultText(level, result, deps) {
+  const verbHtml = `<code>/effort ${deps.escapeHtml(level)}</code>`;
+  if (result.ok) {
+    const lines = [`\u2705 ${verbHtml} \u2014 ${deps.escapeHtml(result.output)}`];
+    if (result.confirmed) {
+      lines.push("<i>Switched mid-conversation \u2014 your next turn re-reads the cached history (slower, one time).</i>");
+    }
+    lines.push(PERSIST_NOTE2);
+    return lines.join(`
+`);
   }
-  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.reason === "session_missing") {
+    return "\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.";
   }
-  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
-    };
+  if (result.reason === "confirm_failed") {
+    const wedged = result.wedged ? " The confirmation prompt may still be open on the pane \u2014 check it." : " The change was cancelled and the pane left as it was.";
+    return `\u274c ${verbHtml} \u2014 couldn't confirm the switch.${wedged}`;
   }
-  return {
-    text: `\u274c ${verbHtml} \u2014 ${deps.escapeHtml(result.errorMessage ?? "inject failed")}`,
-    html: true
-  };
+  return `\u274c ${verbHtml} \u2014 sent, but couldn't confirm it applied. The agent may be mid-turn; check <code>/inject /status</code>.`;
 }
 var EFFORT_CALLBACK_PREFIX = "eff:";
 var EFFORT_CALLBACK_SELECT = "eff:s:";
@@ -45530,18 +45520,20 @@ async function handleEffortMenuCallback(data, 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`;
+    const result = await deps.applyEffort(deps.getAgentName(), level);
+    if (result.ok) {
+      banner = result.confirmed ? `\u2705 Effort \u2192 <code>${deps.escapeHtml(level)}</code> (mid-conversation: next turn re-reads history)` : `\u2705 Effort \u2192 <code>${deps.escapeHtml(level)}</code> for this session`;
       selected = level;
-    } else if (result.errorCode === "session_missing") {
+    } else if (result.reason === "session_missing") {
       banner = "\u274c tmux session not found \u2014 is the agent running under the supervisor?";
+    } else if (result.reason === "confirm_failed") {
+      banner = result.wedged ? "\u26a0\ufe0f Couldn\u2019t confirm the switch \u2014 the prompt may still be open on the pane." : "\u274c Couldn\u2019t confirm the switch \u2014 cancelled, effort unchanged.";
     } else {
-      banner = `\u274c couldn't set effort: ${deps.escapeHtml(result.errorMessage ?? "inject failed")}`;
+      banner = "\u274c Sent, but couldn\u2019t confirm it applied (agent may be mid-turn).";
     }
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
-    banner = `\u274c inject failed: ${deps.escapeHtml(msg)}`;
+    banner = `\u274c failed: ${deps.escapeHtml(msg)}`;
   }
   const menu = buildEffortMenu(deps, selected);
   return {
@@ -45551,6 +45543,80 @@ ${menu.text}` },
   };
 }
 
+// ../src/agents/effort-picker.ts
+var CONFIRM_RE = /Change effort level\?/i;
+function appliedRe(level) {
+  return new RegExp(`${level}\\s*\\u00b7\\s*/effort`);
+}
+function applyLine(pane, level) {
+  const re = new RegExp(`Set effort level to ${level}\\b.*`, "i");
+  for (const line of pane.split(`
+`)) {
+    const m = line.match(re);
+    if (m)
+      return m[0].trim();
+  }
+  return `Set effort level to ${level}`;
+}
+var realSleep2 = (ms) => new Promise((r) => setTimeout(r, ms));
+async function applyEffort(agentName3, level, opts = {}) {
+  const runner = opts._runner ?? makeTmuxRunner2(opts.tmuxBin ?? "tmux");
+  const socket = opts.socketName ?? `switchroom-${agentName3}`;
+  const session = opts.sessionName ?? agentName3;
+  const stepMs = opts.stepMs ?? 600;
+  const timeoutMs = opts.timeoutMs ?? 1e4;
+  const sleep2 = opts._sleep ?? realSleep2;
+  const log = opts._log ?? ((line) => process.stderr.write(`${line}
+`));
+  if (!runner.hasSession(socket, session)) {
+    return { ok: false, reason: "session_missing" };
+  }
+  return withPaneLock(`${socket}:${session}`, async () => {
+    const startedAt = Date.now();
+    const expired2 = () => Date.now() - startedAt >= timeoutMs;
+    try {
+      runner.send(socket, session, ["send-keys", "-l", `/effort ${level}`]);
+      runner.send(socket, session, ["send-keys", "Enter"]);
+      let confirmed = false;
+      let confirmKeys = 0;
+      while (!expired2()) {
+        await sleep2(stepMs);
+        const pane = runner.capture(socket, session) ?? "";
+        if (CONFIRM_RE.test(pane)) {
+          if (confirmKeys >= 2) {
+            runner.send(socket, session, ["send-keys", "Escape"]);
+            await sleep2(stepMs);
+            const after = runner.capture(socket, session) ?? "";
+            log(`effort-picker: confirm modal would not dismiss for ${agentName3} ` + `(socket=${socket}) \u2014 cancelled`);
+            return { ok: false, reason: "confirm_failed", wedged: CONFIRM_RE.test(after) };
+          }
+          runner.send(socket, session, ["send-keys", "Enter"]);
+          confirmed = true;
+          confirmKeys += 1;
+          continue;
+        }
+        if (appliedRe(level).test(pane)) {
+          return { ok: true, level, confirmed, output: applyLine(pane, level) };
+        }
+      }
+      const final = runner.capture(socket, session) ?? "";
+      if (CONFIRM_RE.test(final)) {
+        runner.send(socket, session, ["send-keys", "Escape"]);
+        log(`effort-picker: timeout with modal open for ${agentName3} \u2014 cancelled`);
+        return { ok: false, reason: "confirm_failed", wedged: true };
+      }
+      return { ok: false, reason: "apply_unverified" };
+    } finally {
+      try {
+        const pane = runner.capture(socket, session) ?? "";
+        if (CONFIRM_RE.test(pane)) {
+          runner.send(socket, session, ["send-keys", "Escape"]);
+        }
+      } catch {}
+    }
+  });
+}
+
 // ../src/config/loader.ts
 init_dist();
 init_zod();
@@ -53646,6 +53712,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";
@@ -54317,10 +54392,10 @@ function readTurnActiveMarkerAgeMs(stateDir, now) {
 }
 
 // ../src/build-info.ts
-var VERSION = "0.15.19";
-var COMMIT_SHA = "3f40c6f9";
-var COMMIT_DATE = "2026-06-14T00:06:47Z";
-var LATEST_PR = 2337;
+var VERSION = "0.15.21";
+var COMMIT_SHA = "36706e85";
+var COMMIT_DATE = "2026-06-14T01:34:05Z";
+var LATEST_PR = 2345;
 var COMMITS_AHEAD_OF_TAG = 0;
 
 // gateway/boot-version.ts
@@ -55819,6 +55894,23 @@ function formatFeedElapsed(ms) {
 function turnInFlightForGate() {
   return isDeliveryCutoverEnabled() ? isMachineInTurn() : claudeBusyKeys.size > 0;
 }
+function deliverResumeSyntheticOrBuffer(agent, inbound) {
+  const decision = decideInboundDelivery({
+    turnInFlight: turnInFlightForGate(),
+    isSteering: false,
+    isInterrupt: false
+  });
+  if (decision === "buffer-until-idle") {
+    pendingInboundBuffer.push(agent, inbound);
+    return false;
+  }
+  const delivered = ipcServer.sendToAgent(agent, inbound);
+  if (delivered)
+    markClaudeBusyForInbound(inbound);
+  else
+    pendingInboundBuffer.push(agent, inbound);
+  return delivered;
+}
 var pendingRestarts = new Map;
 var lastSessionActiveFile = null;
 var compactState = initialCompactState();
@@ -59301,11 +59393,7 @@ async function captureProvidedSecret(ctx, chat_id, msgId, value) {
         stage_id: armed.stageId
       }
     };
-    const fdelivered = ipcServer.sendToAgent(armed.agent, failMsg);
-    if (fdelivered)
-      markClaudeBusyForInbound(failMsg);
-    else
-      pendingInboundBuffer.push(armed.agent, failMsg);
+    deliverResumeSyntheticOrBuffer(armed.agent, failMsg);
     return true;
   }
   await switchroomReply(ctx, `\u2705 saved as <code>vault:${escapeHtmlForTg(armed.key)}</code> (masked: <code>${escapeHtmlForTg(maskToken2(value))}</code>). The agent can now reference it.`, { html: true });
@@ -59327,11 +59415,7 @@ async function captureProvidedSecret(ctx, chat_id, msgId, value) {
       stage_id: armed.stageId
     }
   };
-  const delivered = ipcServer.sendToAgent(armed.agent, synthetic);
-  if (delivered)
-    markClaudeBusyForInbound(synthetic);
-  else
-    pendingInboundBuffer.push(armed.agent, synthetic);
+  const delivered = deliverResumeSyntheticOrBuffer(armed.agent, synthetic);
   process.stderr.write(`telegram gateway: secret_provided injection agent=${armed.agent} key=${armed.key} stage=${armed.stageId} delivered=${delivered}
 `);
   return true;
@@ -59393,11 +59477,7 @@ async function handleSecretRequestCallback(ctx, data) {
         stage_id: stageId
       }
     };
-    const delivered = ipcServer.sendToAgent(pending2.agent, synthetic);
-    if (delivered)
-      markClaudeBusyForInbound(synthetic);
-    else
-      pendingInboundBuffer.push(pending2.agent, synthetic);
+    deliverResumeSyntheticOrBuffer(pending2.agent, synthetic);
     return;
   }
   await ctx.answerCallbackQuery().catch(() => {});
@@ -61772,6 +61852,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;
@@ -62304,14 +62404,13 @@ bot.command("model", async (ctx) => {
 });
 function buildEffortDeps() {
   return {
-    inject: injectSlashCommand,
+    applyEffort: (agent, level) => applyEffort(agent, level),
     getAgentName: getMyAgentName,
     getConfiguredEffort: () => {
       const data = switchroomExecJson(["agent", "list"]);
       return data?.agents?.find((a) => a.name === getMyAgentName())?.thinking_effort ?? null;
     },
-    escapeHtml: escapeHtmlForTg,
-    preBlock
+    escapeHtml: escapeHtmlForTg
   };
 }
 function effortMenuReplyMarkup(reply) {
@@ -63578,14 +63677,9 @@ async function performVaultAccessApproval(ctx, pending2, stageId, senderId, atte
     stageId,
     operatorId: senderId
   });
-  const delivered = ipcServer.sendToAgent(pending2.agent, synthetic);
-  if (delivered)
-    markClaudeBusyForInbound(synthetic);
+  const delivered = deliverResumeSyntheticOrBuffer(pending2.agent, synthetic);
   process.stderr.write(`telegram gateway: vault_grant_approved injection agent=${pending2.agent} key=${pending2.key} stage=${stageId} delivered=${delivered}
 `);
-  if (!delivered) {
-    pendingInboundBuffer.push(pending2.agent, synthetic);
-  }
 }
 async function handleVaultRequestAccessCallback(ctx, data) {
   const senderId = String(ctx.from?.id ?? "");
@@ -63627,14 +63721,9 @@ async function handleVaultRequestAccessCallback(ctx, data) {
       stageId,
       operatorId: senderId
     });
-    const denyDelivered = ipcServer.sendToAgent(pending2.agent, denyInbound);
-    if (denyDelivered)
-      markClaudeBusyForInbound(denyInbound);
+    const denyDelivered = deliverResumeSyntheticOrBuffer(pending2.agent, denyInbound);
     process.stderr.write(`telegram gateway: vault_grant_denied injection agent=${pending2.agent} key=${pending2.key} stage=${stageId} delivered=${denyDelivered}
 `);
-    if (!denyDelivered) {
-      pendingInboundBuffer.push(pending2.agent, denyInbound);
-    }
     return;
   }
   if (action === "approve") {
@@ -63726,13 +63815,9 @@ async function handleVaultRequestSaveCallback(ctx, data) {
       stageId,
       operatorId: senderId
     });
-    const dDelivered = ipcServer.sendToAgent(pending2.agent, discardInbound);
-    if (dDelivered)
-      markClaudeBusyForInbound(discardInbound);
+    const dDelivered = deliverResumeSyntheticOrBuffer(pending2.agent, discardInbound);
     process.stderr.write(`telegram gateway: vault_save_discarded injection agent=${pending2.agent} key=${pending2.key} stage=${stageId} delivered=${dDelivered}
 `);
-    if (!dDelivered)
-      pendingInboundBuffer.push(pending2.agent, discardInbound);
     return;
   }
   if (action === "rename") {
@@ -63793,13 +63878,9 @@ async function handleVaultRequestSaveCallback(ctx, data) {
         operatorId: senderId,
         reason: failReason
       });
-      const fDelivered = ipcServer.sendToAgent(pending2.agent, failInbound);
-      if (fDelivered)
-        markClaudeBusyForInbound(failInbound);
+      const fDelivered = deliverResumeSyntheticOrBuffer(pending2.agent, failInbound);
       process.stderr.write(`telegram gateway: vault_save_failed injection agent=${pending2.agent} key=${pending2.key} stage=${stageId} delivered=${fDelivered}
 `);
-      if (!fDelivered)
-        pendingInboundBuffer.push(pending2.agent, failInbound);
       return;
     }
     pendingVaultRequestSaves.delete(stageId);
@@ -63817,13 +63898,9 @@ async function handleVaultRequestSaveCallback(ctx, data) {
       stageId,
       operatorId: senderId
     });
-    const okDelivered = ipcServer.sendToAgent(pending2.agent, okInbound);
-    if (okDelivered)
-      markClaudeBusyForInbound(okInbound);
+    const okDelivered = deliverResumeSyntheticOrBuffer(pending2.agent, okInbound);
     process.stderr.write(`telegram gateway: vault_save_completed injection agent=${pending2.agent} key=${pending2.key} stage=${stageId} delivered=${okDelivered}
 `);
-    if (!okDelivered)
-      pendingInboundBuffer.push(pending2.agent, okInbound);
     return;
   }
   await ctx.answerCallbackQuery({ text: "Unknown action" }).catch(() => {});
@@ -65051,6 +65128,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;
@@ -65515,10 +65642,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}