switchroom 0.15.20 → 0.15.22

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/gateway/ipc-protocol.ts

@@ -391,6 +391,14 @@ export interface RequestConfigFinalizeMessage {
   outcome: "applied" | "reconcile_failed_rolled_back";
   /** Optional short diagnostic appended to the card body. */
   detail?: string;
+  /**
+   * On `applied`: agents that must restart for the edit to go live (claude
+   * loads config at boot). Empty when `fleetWide`. The finalize card offers a
+   * one-tap restart of these. Computed host-side by classifyBlastRadius.
+   */
+  affectedAgents?: string[];
+  /** On `applied`: a shared/inherited key changed → all agents affected. */
+  fleetWide?: boolean;
 }
 
 /**

package/telegram-plugin/gateway/ipc-server.ts

@@ -307,6 +307,16 @@ export function validateClientMessage(msg: unknown): msg is ClientToGateway {
       if (m.detail !== undefined
         && (typeof m.detail !== "string"
           || (m.detail as string).length > 500)) return false;
+      // affectedAgents (optional): a bounded list of kebab-case agent names —
+      // they drive a restart button, so validate shape + charclass even though
+      // the sender (hostd) is trusted (defense in depth).
+      if (m.affectedAgents !== undefined) {
+        if (!Array.isArray(m.affectedAgents) || (m.affectedAgents as unknown[]).length > 64) return false;
+        for (const a of m.affectedAgents as unknown[]) {
+          if (typeof a !== "string" || !/^[a-zA-Z0-9][a-zA-Z0-9_-]{0,63}$/.test(a)) return false;
+        }
+      }
+      if (m.fleetWide !== undefined && typeof m.fleetWide !== "boolean") return false;
       return true;
     }
     case "request_drive_approval": {

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/ipc-validator.test.ts

@@ -332,4 +332,32 @@ describe('validateClientMessage', () => {
       expect(validateClientMessage({ ...valid, ttlMs: '300000' })).toBe(false)
     })
   })
+
+  describe('request_config_finalize — affectedAgents / fleetWide (#2346)', () => {
+    const valid = { type: 'request_config_finalize', requestId: 'r1', outcome: 'applied' }
+
+    it('accepts the bare message and the new optional fields', () => {
+      expect(validateClientMessage(valid)).toBe(true)
+      expect(validateClientMessage({ ...valid, affectedAgents: ['clerk', 'gymbro'], fleetWide: false })).toBe(true)
+      expect(validateClientMessage({ ...valid, affectedAgents: [], fleetWide: true })).toBe(true)
+    })
+
+    it('rejects a non-array affectedAgents', () => {
+      expect(validateClientMessage({ ...valid, affectedAgents: 'clerk' })).toBe(false)
+    })
+
+    it('rejects affectedAgents with an unsafe / non-kebab name (defense in depth)', () => {
+      expect(validateClientMessage({ ...valid, affectedAgents: ['../etc'] })).toBe(false)
+      expect(validateClientMessage({ ...valid, affectedAgents: ['has space'] })).toBe(false)
+      expect(validateClientMessage({ ...valid, affectedAgents: [42] })).toBe(false)
+    })
+
+    it('rejects an over-long affectedAgents list', () => {
+      expect(validateClientMessage({ ...valid, affectedAgents: Array.from({ length: 65 }, (_, i) => `a${i}`) })).toBe(false)
+    })
+
+    it('rejects a non-boolean fleetWide', () => {
+      expect(validateClientMessage({ ...valid, fleetWide: 'yes' })).toBe(false)
+    })
+  })
 })

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", () => {