switchroom 0.15.19 → 0.15.21

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/grant-restart.test.ts

@@ -0,0 +1,38 @@
+/**
+ * Tests for grantRestartDecision — the gating for the "make a just-persisted
+ * grant LIVE" self-restart (item ② config-edit-takes-effect). Pins: kill-switch,
+ * self-agent-only (never a peer/fleet bounce), and turn-deferred-vs-now.
+ */
+
+import { describe, it, expect } from "vitest";
+import { grantRestartDecision } from "../gateway/grant-restart.js";
+
+const base = { killSwitch: undefined, selfAgent: "clerk", agentName: "clerk", turnInFlight: true };
+
+describe("grantRestartDecision", () => {
+  it("defers to turn-complete when a turn is in flight (marker-safe)", () => {
+    expect(grantRestartDecision({ ...base, turnInFlight: true })).toBe("deferred");
+  });
+
+  it("fires now when no turn is in flight", () => {
+    expect(grantRestartDecision({ ...base, turnInFlight: false })).toBe("now");
+  });
+
+  it("is disabled by the kill-switch (SWITCHROOM_AUTORESTART_ON_GRANT=0)", () => {
+    expect(grantRestartDecision({ ...base, killSwitch: "0" })).toBe("disabled");
+  });
+
+  it("default-on for any non-'0' kill-switch value", () => {
+    expect(grantRestartDecision({ ...base, killSwitch: "" })).toBe("deferred");
+    expect(grantRestartDecision({ ...base, killSwitch: "1" })).toBe("deferred");
+  });
+
+  it("NEVER restarts a peer — self-agent only", () => {
+    // edit targets a different agent than the gateway's own identity
+    expect(grantRestartDecision({ ...base, selfAgent: "clerk", agentName: "gymbro" })).toBe("disabled");
+  });
+
+  it("is disabled when self identity is unknown", () => {
+    expect(grantRestartDecision({ ...base, selfAgent: undefined })).toBe("disabled");
+  });
+});

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\)/);
+  });
+});

package/telegram-plugin/welcome-text.ts

@@ -270,7 +270,7 @@ export const switchroomHelpCommandNames = [
   "agents", "agentstart", "stop", "restart", "logs", "memory",
   // Auth & config — consolidated onto the `/auth` dashboard.
   "auth", "model",
-  "topics", "update", "version",
+  "topics", "update", "version", "whoami",
   "permissions", "grant", "dangerous", "vault", "doctor",
   "commands",
   // Note: "reconcile" is a deprecated alias still handled as a bot command
@@ -374,6 +374,7 @@ export function switchroomHelpText(agentName: string): string {
     `<code>/update</code> — dry-run plan; <code>/update apply</code> — actually pull images, reconcile, restart`,
     `<code>/restart [name|all]</code> — bounce agent (drains in-flight turn by default)`,
     `<code>/version</code> — show versions + running agent health summary`,
+    `<code>/whoami</code> — this agent's sandbox: tools, MCP, vault key-names, powers`,
     ``,
     `<b>Auth &amp; config</b>`,
     `<code>/auth</code> — auth status or actions`,