switchroom 0.15.20 → 0.15.21

package/dist/cli/switchroom.js

@@ -50477,8 +50477,8 @@ var {
 } = import__.default;
 
 // src/build-info.ts
-var VERSION = "0.15.20";
-var COMMIT_SHA = "0b63ab9e";
+var VERSION = "0.15.21";
+var COMMIT_SHA = "36706e85";
 
 // src/cli/agent.ts
 init_source();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "switchroom",
-  "version": "0.15.20",
+  "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/telegram-plugin/dist/gateway/gateway.js

@@ -45454,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:";
@@ -45531,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 {
@@ -45552,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();
@@ -54327,11 +54392,11 @@ function readTurnActiveMarkerAgeMs(stateDir, now) {
 }
 
 // ../src/build-info.ts
-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 = 5;
+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
 function formatRelativeAgo(iso) {
@@ -55829,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();
@@ -59311,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 });
@@ -59337,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;
@@ -59403,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(() => {});
@@ -62334,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) {
@@ -63608,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 ?? "");
@@ -63657,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") {
@@ -63756,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") {
@@ -63823,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);
@@ -63847,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(() => {});

package/telegram-plugin/gateway/effort-command.ts

@@ -22,7 +22,7 @@
  * unit-testable without booting the bot.
  */
 
-import type { InjectResult } from '../../src/agents/inject.js'
+import type { EffortApplyResult } from '../../src/agents/effort-picker.js'
 
 /**
  * The effort levels the installed CLI accepts (`claude --help`:
@@ -66,8 +66,14 @@ export function parseEffortCommand(text: string): ParsedEffortCommand | null {
 }
 
 export interface EffortCommandDeps {
-  /** Inject primitive — wired to injectSlashCommand in the gateway. */
-  inject: (agent: string, command: string) => Promise<InjectResult>
+  /**
+   * Apply an effort level to the live session. Wired to `applyEffort`
+   * (src/agents/effort-picker.ts), which types `/effort <level>` AND drives
+   * the "Change effort level?" confirmation modal that claude shows when the
+   * switch would invalidate a cached conversation — so it never wedges the
+   * pane the way a bare inject would.
+   */
+  applyEffort: (agent: string, level: string) => Promise<EffortApplyResult>
   getAgentName: () => string
   /**
    * The agent's cascade-resolved `thinking_effort` from
@@ -76,7 +82,6 @@ export interface EffortCommandDeps {
    */
   getConfiguredEffort: () => string | null
   escapeHtml: (s: string) => string
-  preBlock: (s: string) => string
 }
 
 export interface EffortCommandReply {
@@ -127,52 +132,48 @@ export async function handleEffortCommand(
     return helpText(deps, `not a valid effort level: ${parsed.level}`)
   }
   const verbHtml = `<code>/effort ${deps.escapeHtml(parsed.level)}</code>`
-  let result: InjectResult
+  let result: EffortApplyResult
   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: `❌ ${verbHtml} — inject failed: ${deps.escapeHtml(msg)}`, html: true }
+    return { text: `❌ ${verbHtml} — failed: ${deps.escapeHtml(msg)}`, html: true }
   }
+  return { text: applyResultText(parsed.level, result, deps), html: true }
+}
 
-  if (result.outcome === 'ok') {
-    return {
-      text: [
-        `${verbHtml}`,
-        deps.preBlock(result.output),
-        ...(result.truncated ? ['<i>truncated</i>'] : []),
-        PERSIST_NOTE,
-      ].join('\n'),
-      html: true,
-    }
-  }
-  if (result.outcome === 'ok_no_output') {
-    return {
-      text: [
-        `${verbHtml} — sent, but no response captured. The agent may be mid-turn; check <code>/inject /status</code> to confirm the active effort.`,
-        PERSIST_NOTE,
-      ].join('\n'),
-      html: true,
+/**
+ * Render an effort-apply outcome. `confirmed` means a "Change effort level?"
+ * modal was answered — switching mid-conversation re-reads the history, so we
+ * say so honestly rather than just claiming success.
+ */
+function applyResultText(level: string, result: EffortApplyResult, deps: EffortCommandDeps): string {
+  const verbHtml = `<code>/effort ${deps.escapeHtml(level)}</code>`
+  if (result.ok) {
+    const lines = [`✅ ${verbHtml} — ${deps.escapeHtml(result.output)}`]
+    if (result.confirmed) {
+      lines.push('<i>Switched mid-conversation — your next turn re-reads the cached history (slower, one time).</i>')
     }
+    lines.push(PERSIST_NOTE)
+    return lines.join('\n')
   }
-  // outcome === 'failed'
-  if (result.errorCode === 'session_missing') {
-    return {
-      text:
-        '❌ tmux session not found — 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 === 'session_missing') {
+    return '❌ tmux session not found — the agent must be running under the tmux supervisor (the default). Remove <code>experimental.legacy_pty: true</code> if set.'
   }
-  return {
-    text: `❌ ${verbHtml} — ${deps.escapeHtml(result.errorMessage ?? 'inject failed')}`,
-    html: true,
+  if (result.reason === 'confirm_failed') {
+    const wedged = result.wedged
+      ? ' The confirmation prompt may still be open on the pane — check it.'
+      : ' The change was cancelled and the pane left as it was.'
+    return `❌ ${verbHtml} — couldn't confirm the switch.${wedged}`
   }
+  // apply_unverified
+  return `❌ ${verbHtml} — sent, but couldn't confirm it applied. The agent may be mid-turn; check <code>/inject /status</code>.`
 }
 
 // ---------------------------------------------------------------------------
 // Button menu — five fixed levels, the live one marked ✅. No live discovery
-// (the levels don't churn) and no picker-driving (the inline `/effort <level>`
-// form sets it directly), so this is far simpler than the /model menu.
+// (the levels don't churn). A tap applies the level via applyEffort, which
+// drives the confirmation modal so it never wedges the pane.
 // ---------------------------------------------------------------------------
 
 export interface EffortMenuKeyboardButton {
@@ -231,9 +232,11 @@ export interface EffortCallbackOutcome {
 }
 
 /**
- * Handle an `eff:*` callback tap. `eff:s:<level>` injects claude's
- * `/effort <level>` and re-renders the menu with a one-line banner and the
- * new level checked. Never throws — failures render as a banner.
+ * Handle an `eff:*` callback tap. `eff:s:<level>` applies the level via
+ * applyEffort (which drives the confirmation modal, so a mid-conversation
+ * switch confirms cleanly instead of wedging the pane) and re-renders the
+ * menu with a one-line banner and the new level checked. Never throws —
+ * failures render as a banner.
  */
 export async function handleEffortMenuCallback(
   data: string,
@@ -249,21 +252,27 @@ export async function handleEffortMenuCallback(
   let banner: string
   let selected: string | undefined
   try {
-    const result = await deps.inject(deps.getAgentName(), `/effort ${level}`)
-    if (result.outcome === 'ok' || result.outcome === 'ok_no_output') {
-      banner = `✅ Effort → <code>${deps.escapeHtml(level)}</code> for this session`
+    const result = await deps.applyEffort(deps.getAgentName(), level)
+    if (result.ok) {
+      banner = result.confirmed
+        ? `✅ Effort → <code>${deps.escapeHtml(level)}</code> (mid-conversation: next turn re-reads history)`
+        : `✅ Effort → <code>${deps.escapeHtml(level)}</code> for this session`
       selected = level
-    } else if (result.errorCode === 'session_missing') {
+    } else if (result.reason === 'session_missing') {
       banner = '❌ tmux session not found — is the agent running under the supervisor?'
+    } else if (result.reason === 'confirm_failed') {
+      banner = result.wedged
+        ? '⚠️ Couldn’t confirm the switch — the prompt may still be open on the pane.'
+        : '❌ Couldn’t confirm the switch — cancelled, effort unchanged.'
     } else {
-      banner = `❌ couldn't set effort: ${deps.escapeHtml(result.errorMessage ?? 'inject failed')}`
+      banner = '❌ Sent, but couldn’t confirm it applied (agent may be mid-turn).'
     }
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err)
-    banner = `❌ inject failed: ${deps.escapeHtml(msg)}`
+    banner = `❌ failed: ${deps.escapeHtml(msg)}`
   }
   // Re-render with the just-selected level checked (or the configured
-  // default if the inject failed) and the banner on top.
+  // default if it didn't apply) and the banner on top.
   const menu = buildEffortMenu(deps, selected)
   return {
     reply: { ...menu, text: `${banner}\n${menu.text}` },

package/telegram-plugin/gateway/gateway.ts

@@ -280,6 +280,7 @@ import {
   type EffortCommandDeps,
   type EffortMenuReply,
 } from './effort-command.js'
+import { applyEffort } from '../../src/agents/effort-picker.js'
 import { type BannerState } from '../slot-banner.js'
 import { refreshBanner } from '../slot-banner-driver.js'
 import { loadConfig as loadSwitchroomConfig, findConfigFile as findSwitchroomConfigFile } from '../../src/config/loader.js'; import { resolveAgentConfig } from '../../src/config/merge.js'
@@ -1718,6 +1719,53 @@ function formatFeedElapsed(ms: number): string {
 function turnInFlightForGate(): boolean {
   return isDeliveryCutoverEnabled() ? isMachineInTurn() : claudeBusyKeys.size > 0
 }
+
+/**
+ * Deliver a synthetic "resume" inbound — the wake-up the gateway sends
+ * after an operator approves/denies a vault grant, provides/declines a
+ * requested secret, or completes/fails/discards a vault save — turn-gated
+ * exactly like a real Telegram inbound.
+ *
+ * THE BUG (clerk `hotdoc/credentials`, 2026-06-13): these synthetics did a
+ * raw `ipcServer.sendToAgent` and buffered ONLY on `delivered=false`
+ * (bridge disconnected). But approvals routinely land WHILE the agent's
+ * grant-requesting turn is still finishing — the socket write succeeds
+ * (`delivered=true`) yet claude is mid-turn, so the channel notification
+ * is typed into its TUI composer and stranded by the turn-completion race
+ * (#1556, the lawgpt wedge). `delivered=true` → the buffer never rescued
+ * it → the agent sat idle until the operator manually poked it. Observed:
+ * injection 179ms BEFORE turn_end, then 2 minutes of silence.
+ *
+ * Fix: route through the SAME `decideInboundDelivery` gate the Telegram
+ * `handleInbound` path uses. Mid-turn → `buffer-until-idle` (the
+ * turn-complete hook `releaseTurnBufferGate → drainBufferedIfAllowed`,
+ * plus the idle-drain timer, flush it the instant claude goes idle, where
+ * it lands cleanly as a fresh turn). Idle → deliver now; buffer on a
+ * genuine delivery miss exactly as before. Unlike the cron `inject_inbound`
+ * path (deliberately ungated — at-least-once replay), a one-shot resume
+ * synthetic must never strand, so it IS gated.
+ *
+ * Returns true iff delivered to the bridge now (false = buffered/held;
+ * the caller's forensic log records this as `delivered=false`, which now
+ * means "held mid-turn OR bridge-down" — both are "will flush when idle",
+ * never "dropped").
+ */
+function deliverResumeSyntheticOrBuffer(agent: string, inbound: InboundMessage): boolean {
+  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
+}
+
 const pendingRestarts = new Map<string, number>()  // agentName -> timestamp when restart was requested
 
 // ─── Proactive context compaction (session.max_context_tokens) ──────────
@@ -8908,9 +8956,7 @@ async function captureProvidedSecret(
         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
   }
 
@@ -8943,9 +8989,7 @@ async function captureProvidedSecret(
       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}\n`,
   )
@@ -9026,9 +9070,7 @@ async function handleSecretRequestCallback(ctx: Context, data: string): Promise<
         stage_id: stageId,
       },
     }
-    const delivered = ipcServer.sendToAgent(pending.agent, synthetic)
-    if (delivered) markClaudeBusyForInbound(synthetic)
-    else pendingInboundBuffer.push(pending.agent, synthetic)
+    deliverResumeSyntheticOrBuffer(pending.agent, synthetic)
     return
   }
 
@@ -14286,7 +14328,7 @@ bot.command('model', async ctx => {
 // in effort-command.ts so it's unit-testable without booting the bot.
 function buildEffortDeps(): EffortCommandDeps {
   return {
-    inject: injectSlashCommandImpl,
+    applyEffort: (agent, level) => applyEffort(agent, level),
     getAgentName: getMyAgentName,
     getConfiguredEffort: () => {
       type AgentListResp = { agents: Array<{ name: string; thinking_effort?: string | null }> }
@@ -14294,7 +14336,6 @@ function buildEffortDeps(): EffortCommandDeps {
       return data?.agents?.find(a => a.name === getMyAgentName())?.thinking_effort ?? null
     },
     escapeHtml: escapeHtmlForTg,
-    preBlock,
   }
 }
 
@@ -16612,22 +16653,14 @@ async function performVaultAccessApproval(
     stageId,
     operatorId: senderId,
   })
-  const delivered = ipcServer.sendToAgent(pending.agent, synthetic)
-  if (delivered) markClaudeBusyForInbound(synthetic)
+  // Turn-gated via deliverResumeSyntheticOrBuffer: mid-turn → buffer
+  // (flushed at turn-end) so the resume never strands in claude's
+  // composer (#1556); idle → deliver; bridge-down → buffer (#1150).
+  const delivered = deliverResumeSyntheticOrBuffer(pending.agent, synthetic)
   process.stderr.write(
     `telegram gateway: vault_grant_approved injection agent=${pending.agent} ` +
     `key=${pending.key} stage=${stageId} delivered=${delivered}\n`,
   )
-  // #1150 root cause: if `delivered=false` the bridge wasn't connected
-  // at send-time (mid-reconnect, claude-session bouncing between
-  // turns, etc). Pre-fix this just logged + dropped — the agent stayed
-  // idle forever and the operator had to poke. Now we buffer the
-  // inbound so the next bridge-register call drains it. Bounded to
-  // 32 entries per agent (see pending-inbound-buffer.ts) — a never-
-  // reconnecting bridge can't fill memory.
-  if (!delivered) {
-    pendingInboundBuffer.push(pending.agent, synthetic)
-  }
 }
 
 async function handleVaultRequestAccessCallback(ctx: Context, data: string): Promise<void> {
@@ -16693,15 +16726,11 @@ async function handleVaultRequestAccessCallback(ctx: Context, data: string): Pro
       stageId,
       operatorId: senderId,
     })
-    const denyDelivered = ipcServer.sendToAgent(pending.agent, denyInbound)
-    if (denyDelivered) markClaudeBusyForInbound(denyInbound)
+    const denyDelivered = deliverResumeSyntheticOrBuffer(pending.agent, denyInbound)
     process.stderr.write(
       `telegram gateway: vault_grant_denied injection agent=${pending.agent} ` +
       `key=${pending.key} stage=${stageId} delivered=${denyDelivered}\n`,
     )
-    if (!denyDelivered) {
-      pendingInboundBuffer.push(pending.agent, denyInbound)
-    }
     return
   }
 
@@ -16872,13 +16901,11 @@ async function handleVaultRequestSaveCallback(ctx: Context, data: string): Promi
       stageId,
       operatorId: senderId,
     })
-    const dDelivered = ipcServer.sendToAgent(pending.agent, discardInbound)
-    if (dDelivered) markClaudeBusyForInbound(discardInbound)
+    const dDelivered = deliverResumeSyntheticOrBuffer(pending.agent, discardInbound)
     process.stderr.write(
       `telegram gateway: vault_save_discarded injection agent=${pending.agent} ` +
       `key=${pending.key} stage=${stageId} delivered=${dDelivered}\n`,
     )
-    if (!dDelivered) pendingInboundBuffer.push(pending.agent, discardInbound)
     return
   }
 
@@ -17001,13 +17028,11 @@ async function handleVaultRequestSaveCallback(ctx: Context, data: string): Promi
         operatorId: senderId,
         reason: failReason,
       })
-      const fDelivered = ipcServer.sendToAgent(pending.agent, failInbound)
-      if (fDelivered) markClaudeBusyForInbound(failInbound)
+      const fDelivered = deliverResumeSyntheticOrBuffer(pending.agent, failInbound)
       process.stderr.write(
         `telegram gateway: vault_save_failed injection agent=${pending.agent} ` +
         `key=${pending.key} stage=${stageId} delivered=${fDelivered}\n`,
       )
-      if (!fDelivered) pendingInboundBuffer.push(pending.agent, failInbound)
       return
     }
 
@@ -17036,13 +17061,11 @@ async function handleVaultRequestSaveCallback(ctx: Context, data: string): Promi
       stageId,
       operatorId: senderId,
     })
-    const okDelivered = ipcServer.sendToAgent(pending.agent, okInbound)
-    if (okDelivered) markClaudeBusyForInbound(okInbound)
+    const okDelivered = deliverResumeSyntheticOrBuffer(pending.agent, okInbound)
     process.stderr.write(
       `telegram gateway: vault_save_completed injection agent=${pending.agent} ` +
       `key=${pending.key} stage=${stageId} delivered=${okDelivered}\n`,
     )
-    if (!okDelivered) pendingInboundBuffer.push(pending.agent, okInbound)
     return
   }
 

package/telegram-plugin/tests/effort-command.test.ts

@@ -21,40 +21,29 @@ import {
   EFFORT_CALLBACK_PREFIX,
   type EffortCommandDeps,
 } from "../gateway/effort-command.js";
-import type { InjectResult } from "../../src/agents/inject.js";
-
-function okResult(output: string): InjectResult {
-  return {
-    outcome: "ok",
-    output,
-    truncated: false,
-    command: "/effort",
-    meta: { description: "Set reasoning effort", expectsOutput: true },
-  };
+import type { EffortApplyResult } from "../../src/agents/effort-picker.js";
+
+function applyOk(level: string, confirmed = false): EffortApplyResult {
+  return { ok: true, level, confirmed, output: `Set effort level to ${level}` };
 }
 
-function failedResult(errorMessage: string): InjectResult {
-  return {
-    outcome: "failed",
-    output: "",
-    truncated: false,
-    command: "/effort",
-    errorMessage,
-    meta: { description: "Set reasoning effort", expectsOutput: true },
-  };
+function applyFail(
+  reason: "session_missing" | "confirm_failed" | "apply_unverified",
+  wedged?: boolean,
+): EffortApplyResult {
+  return { ok: false, reason, ...(wedged !== undefined ? { wedged } : {}) };
 }
 
 function makeDeps(overrides: Partial<EffortCommandDeps> = {}) {
-  const calls: Array<{ agent: string; command: string }> = [];
+  const calls: Array<{ agent: string; level: string }> = [];
   const deps: EffortCommandDeps = {
-    inject: async (agent, command) => {
-      calls.push({ agent, command });
-      return okResult("Set effort level to high");
+    applyEffort: async (agent, level) => {
+      calls.push({ agent, level });
+      return applyOk(level);
     },
     getAgentName: () => "carrie",
     getConfiguredEffort: () => "low",
     escapeHtml: (s) => s,
-    preBlock: (s) => `<pre>${s}</pre>`,
     ...overrides,
   };
   return { deps, calls };
@@ -127,18 +116,24 @@ describe("effort-command: handler", () => {
     expect(r.text).toContain("low");
   });
 
-  it("set injects exactly '/effort <level>' and relays output", async () => {
+  it("set applies exactly the level and relays output", async () => {
     const { deps, calls } = makeDeps();
     const r = await handleEffortCommand({ kind: "set", level: "high" }, deps);
-    expect(calls).toEqual([{ agent: "carrie", command: "/effort high" }]);
+    expect(calls).toEqual([{ agent: "carrie", level: "high" }]);
     expect(r.text).toContain("Set effort level to high");
     expect(r.text).toMatch(/reverts to the configured default/);
   });
 
-  it("set surfaces an inject failure", async () => {
-    const { deps } = makeDeps({ inject: async () => failedResult("pane locked") });
+  it("set notes the re-read cost when a confirmation was needed", async () => {
+    const { deps } = makeDeps({ applyEffort: async (_a, l) => applyOk(l, true) });
+    const r = await handleEffortCommand({ kind: "set", level: "high" }, deps);
+    expect(r.text).toMatch(/re-reads the cached history/);
+  });
+
+  it("set surfaces a confirm_failed outcome honestly", async () => {
+    const { deps } = makeDeps({ applyEffort: async () => applyFail("confirm_failed", false) });
     const r = await handleEffortCommand({ kind: "set", level: "max" }, deps);
-    expect(r.text).toContain("pane locked");
+    expect(r.text).toContain("couldn't confirm the switch");
     expect(r.text).toContain("❌");
   });
 
@@ -146,7 +141,7 @@ describe("effort-command: handler", () => {
     const { deps, calls } = makeDeps();
     // Hand-craft a parsed object that skipped the parser's gate.
     const r = await handleEffortCommand({ kind: "set", level: "evil; rm -rf" as never }, deps);
-    expect(calls).toEqual([]); // never injected
+    expect(calls).toEqual([]); // never applied
     expect(r.text).toMatch(/not a valid effort level/);
   });
 });
@@ -164,24 +159,38 @@ describe("effort-command: menu + callback", () => {
     expect(menu.keyboard![0]).toHaveLength(5);
   });
 
-  it("callback eff:s:<level> injects the level and checks it in the re-render", async () => {
+  it("callback eff:s:<level> applies the level and checks it in the re-render", async () => {
     const { deps, calls } = makeDeps();
     const out = await handleEffortMenuCallback(effortSelectCallbackData("xhigh"), deps);
-    expect(calls).toEqual([{ agent: "carrie", command: "/effort xhigh" }]);
+    expect(calls).toEqual([{ agent: "carrie", level: "xhigh" }]);
     expect(out.selectedEffort).toBe("xhigh");
     expect(out.reply.text).toContain("Effort → ");
     const checked = out.reply.keyboard!.flat().find((b) => b.text.startsWith("✅"));
     expect(checked?.text).toBe("✅ xhigh");
   });
 
-  it("callback with a failed inject keeps the menu and shows the error, no selection", async () => {
-    const { deps } = makeDeps({ inject: async () => failedResult("session_missing") });
+  it("callback notes the re-read when a confirmation was answered", async () => {
+    const { deps } = makeDeps({ applyEffort: async (_a, l) => applyOk(l, true) });
+    const out = await handleEffortMenuCallback(effortSelectCallbackData("high"), deps);
+    expect(out.reply.text).toMatch(/re-reads history/);
+    expect(out.selectedEffort).toBe("high");
+  });
+
+  it("callback with a failed apply keeps the menu and shows the error, no selection", async () => {
+    const { deps } = makeDeps({ applyEffort: async () => applyFail("session_missing") });
     const out = await handleEffortMenuCallback(effortSelectCallbackData("max"), deps);
     expect(out.selectedEffort).toBeUndefined();
     expect(out.reply.text).toContain("❌");
     expect(out.reply.keyboard!.flat()).toHaveLength(5); // buttons preserved
   });
 
+  it("callback surfaces a wedged confirm_failed as a warning, no selection", async () => {
+    const { deps } = makeDeps({ applyEffort: async () => applyFail("confirm_failed", true) });
+    const out = await handleEffortMenuCallback(effortSelectCallbackData("max"), deps);
+    expect(out.selectedEffort).toBeUndefined();
+    expect(out.reply.text).toMatch(/may still be open/);
+  });
+
   it("callback ignores a malformed level", async () => {
     const { deps, calls } = makeDeps();
     const out = await handleEffortMenuCallback(`${EFFORT_CALLBACK_PREFIX}s:bogus`, deps);

package/telegram-plugin/tests/vault-grant-auto-resume.test.ts

@@ -39,17 +39,28 @@ function extractPerformBlock(): string {
 describe("performVaultAccessApproval injects a synthetic inbound on success (#1052)", () => {
   const block = extractPerformBlock();
 
-  it("calls ipcServer.sendToAgent AFTER successful mint + token-write", () => {
+  it("routes the resume injection through the turn-gated helper AFTER successful mint + token-write", () => {
     // fails when: the auto-resume injection gets dropped. Pre-fix
     // operator had to message the agent again to resume the task —
     // the injection is the load-bearing wiring.
-    expect(block, "missing ipcServer.sendToAgent call").toMatch(/ipcServer\.sendToAgent\(/);
+    //
+    // The raw `ipcServer.sendToAgent` was replaced by
+    // `deliverResumeSyntheticOrBuffer` (the mid-turn-strand fix,
+    // 2026-06-14): a resume delivered while the grant-requesting turn
+    // is still finishing used to strand in claude's composer
+    // (delivered=true but mid-turn → #1556). The helper turn-gates the
+    // send (buffer-until-idle when a turn is in flight) so the resume
+    // always lands as a fresh turn. Pinning the helper call (not raw
+    // sendToAgent) is the new load-bearing contract.
+    expect(block, "missing deliverResumeSyntheticOrBuffer call").toMatch(
+      /deliverResumeSyntheticOrBuffer\(/,
+    );
     // Must run AFTER the mint-success path (i.e., after the
     // `result.kind === 'error'` early-return guard).
     const errorReturn = block.indexOf("result.kind === 'error'");
-    const sendIdx = block.indexOf("ipcServer.sendToAgent(");
+    const sendIdx = block.indexOf("deliverResumeSyntheticOrBuffer(");
     expect(errorReturn).toBeGreaterThan(0);
-    expect(sendIdx, "sendToAgent must come AFTER the error-return early exit").toBeGreaterThan(errorReturn);
+    expect(sendIdx, "the resume helper must come AFTER the error-return early exit").toBeGreaterThan(errorReturn);
   });
 
   it("delegates inbound construction to buildVaultGrantApprovedInbound", () => {

package/telegram-plugin/tests/vault-resume-turn-gated.test.ts

@@ -0,0 +1,97 @@
+/**
+ * Regression guard — vault/secret RESUME synthetics are turn-gated
+ * (the clerk `hotdoc/credentials` mid-turn-strand, 2026-06-14).
+ *
+ * THE BUG: when an operator approved a vault grant (or provided a
+ * secret, or completed a save) WHILE the agent's grant-requesting turn
+ * was still finishing, the gateway did a raw `ipcServer.sendToAgent` of
+ * the resume synthetic. The socket write succeeded (`delivered=true`)
+ * but claude was mid-turn, so the channel notification was typed into
+ * its TUI composer and stranded by the turn-completion race (#1556).
+ * The pending-inbound buffer never rescued it (it only catches
+ * `delivered=false`), so the agent sat idle until the operator manually
+ * poked it.
+ *
+ * Live proof (clerk, 2026-06-13 22:10:57):
+ *   22:10:57.098  vault_grant_approved injection delivered=true
+ *   22:10:57.277  turn_end #14081 finalAnswer=true   (still mid-turn!)
+ *   22:12:57.713  inbound msg=14085 → turnStart       (operator poke, 2m later)
+ *
+ * THE FIX: every resume synthetic goes through
+ * `deliverResumeSyntheticOrBuffer`, which consults the SAME
+ * `decideInboundDelivery` gate the Telegram handleInbound path uses —
+ * mid-turn → `buffer-until-idle` (flushed cleanly at turn-end). This
+ * file pins (a) the gate decision for a resume synthetic's
+ * shape, and (b) that no resume callsite regressed to a raw
+ * `ipcServer.sendToAgent`.
+ */
+import { describe, it, expect } from "vitest";
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { decideInboundDelivery } from "../gateway/inbound-delivery-gate.js";
+
+const gatewaySrc = readFileSync(
+  resolve(__dirname, "..", "gateway", "gateway.ts"),
+  "utf-8",
+);
+
+describe("resume synthetics use the turn-gate (mid-turn → buffer)", () => {
+  it("a resume synthetic's gate shape buffers mid-turn, delivers when idle", () => {
+    // A resume synthetic is never steering and never an interrupt — the
+    // exact inputs deliverResumeSyntheticOrBuffer passes to the gate.
+    const shape = { isSteering: false as const, isInterrupt: false as const };
+    expect(decideInboundDelivery({ ...shape, turnInFlight: true })).toBe(
+      "buffer-until-idle",
+    );
+    expect(decideInboundDelivery({ ...shape, turnInFlight: false })).toBe(
+      "deliver",
+    );
+  });
+
+  it("the helper exists and gates on decideInboundDelivery before sending", () => {
+    const start = gatewaySrc.indexOf(
+      "function deliverResumeSyntheticOrBuffer",
+    );
+    expect(start, "deliverResumeSyntheticOrBuffer helper missing").toBeGreaterThan(0);
+    const body = gatewaySrc.slice(start, start + 900);
+    // Gate consulted...
+    expect(body).toMatch(/decideInboundDelivery\(/);
+    // ...and the buffer-until-idle branch buffers BEFORE any send.
+    const gateIdx = body.indexOf("decideInboundDelivery(");
+    const bufferIdx = body.indexOf("pendingInboundBuffer.push(");
+    const sendIdx = body.indexOf("ipcServer.sendToAgent(");
+    expect(gateIdx).toBeGreaterThan(0);
+    expect(bufferIdx, "must buffer in the helper").toBeGreaterThan(gateIdx);
+    expect(sendIdx, "must still deliver in the idle branch").toBeGreaterThan(gateIdx);
+    expect(bufferIdx, "buffer-until-idle branch precedes the send branch").toBeLessThan(sendIdx);
+  });
+
+  it("no resume synthetic is sent via a raw ungated ipcServer.sendToAgent", () => {
+    // Every resume wake-up — vault_grant_approved/denied, secret_provided/
+    // declined, secret_provide_failed, vault_save_completed/failed/discarded
+    // — must route through the helper. A raw sendToAgent of one of these
+    // named inbound vars would reintroduce the mid-turn strand. The helper
+    // deliberately names its param `inbound` (NOT any of these), so the
+    // ONLY legitimate raw sendToAgent is the helper's own
+    // `ipcServer.sendToAgent(agent, inbound)`; every resume-synthetic var
+    // name below must be absent as a raw send argument.
+    const rawResumeSends = [
+      ...gatewaySrc.matchAll(
+        /ipcServer\.sendToAgent\([^,]+,\s*(synthetic|failMsg|denyInbound|discardInbound|failInbound|okInbound)\)/g,
+      ),
+    ];
+    expect(
+      rawResumeSends.map((m) => m[1]),
+      "resume synthetic sent via raw sendToAgent — must use deliverResumeSyntheticOrBuffer",
+    ).toEqual([]);
+  });
+
+  it("the helper's send uses a param name distinct from every resume var (keeps the grep guard honest)", () => {
+    // If the helper param were renamed back to `synthetic`, the guard
+    // above would get a false pass (the helper's own send would mask a
+    // regressed callsite). Pin the param name.
+    const start = gatewaySrc.indexOf("function deliverResumeSyntheticOrBuffer");
+    const sig = gatewaySrc.slice(start, start + 120);
+    expect(sig).toMatch(/deliverResumeSyntheticOrBuffer\(agent: string, inbound: InboundMessage\)/);
+  });
+});