switchroom 0.15.17 → 0.15.19

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

@@ -0,0 +1,191 @@
+/**
+ * `/effort` Telegram command — parser + handler + menu coverage.
+ *
+ * Guarantees mirrored from `/model`:
+ *   1. The argument is allowlist-gated before it's typed into the tmux
+ *      pane — only the five levels claude accepts, nothing else.
+ *   2. The set path injects exactly `/effort <level>` (claude's own REPL
+ *      verb, on the inject allowlist) and relays the captured output with
+ *      the session-only / reverts-on-restart caveat.
+ *   3. The bare form renders a five-button menu; a tap injects the level.
+ */
+import { describe, it, expect } from "vitest";
+import {
+  parseEffortCommand,
+  handleEffortCommand,
+  isValidEffortArg,
+  EFFORT_LEVELS,
+  buildEffortMenu,
+  handleEffortMenuCallback,
+  effortSelectCallbackData,
+  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 },
+  };
+}
+
+function failedResult(errorMessage: string): InjectResult {
+  return {
+    outcome: "failed",
+    output: "",
+    truncated: false,
+    command: "/effort",
+    errorMessage,
+    meta: { description: "Set reasoning effort", expectsOutput: true },
+  };
+}
+
+function makeDeps(overrides: Partial<EffortCommandDeps> = {}) {
+  const calls: Array<{ agent: string; command: string }> = [];
+  const deps: EffortCommandDeps = {
+    inject: async (agent, command) => {
+      calls.push({ agent, command });
+      return okResult("Set effort level to high");
+    },
+    getAgentName: () => "carrie",
+    getConfiguredEffort: () => "low",
+    escapeHtml: (s) => s,
+    preBlock: (s) => `<pre>${s}</pre>`,
+    ...overrides,
+  };
+  return { deps, calls };
+}
+
+describe("effort-command: levels + validation", () => {
+  it("exposes exactly the five CLI levels in faster→smarter order", () => {
+    expect(EFFORT_LEVELS).toEqual(["low", "medium", "high", "xhigh", "max"]);
+  });
+
+  it("isValidEffortArg accepts levels case-insensitively, rejects others", () => {
+    for (const l of EFFORT_LEVELS) {
+      expect(isValidEffortArg(l)).toBe(true);
+      expect(isValidEffortArg(l.toUpperCase())).toBe(true);
+    }
+    for (const bad of ["", "highest", "fast", "/effort", "low high", "9"]) {
+      expect(isValidEffortArg(bad)).toBe(false);
+    }
+  });
+});
+
+describe("effort-command: parser", () => {
+  it("bare /effort → show", () => {
+    expect(parseEffortCommand("/effort")).toEqual({ kind: "show" });
+    expect(parseEffortCommand("/effort   ")).toEqual({ kind: "show" });
+  });
+
+  it("/effort@bot suffix is tolerated", () => {
+    expect(parseEffortCommand("/effort@carrie_bot")).toEqual({ kind: "show" });
+  });
+
+  it("/effort <level> → set, normalized to lowercase", () => {
+    expect(parseEffortCommand("/effort high")).toEqual({ kind: "set", level: "high" });
+    expect(parseEffortCommand("/effort XHIGH")).toEqual({ kind: "set", level: "xhigh" });
+  });
+
+  it("/effort help → help", () => {
+    expect(parseEffortCommand("/effort help")).toEqual({ kind: "help" });
+  });
+
+  it("invalid level → help with a reason", () => {
+    const p = parseEffortCommand("/effort turbo");
+    expect(p?.kind).toBe("help");
+    expect((p as { reason?: string }).reason).toMatch(/not a valid effort level/);
+  });
+
+  it("more than one token → help", () => {
+    const p = parseEffortCommand("/effort high please");
+    expect(p?.kind).toBe("help");
+    expect((p as { reason?: string }).reason).toMatch(/single level/);
+  });
+
+  it("non-/effort text → null", () => {
+    expect(parseEffortCommand("/model opus")).toBeNull();
+    expect(parseEffortCommand("hello")).toBeNull();
+  });
+});
+
+describe("effort-command: handler", () => {
+  it("show renders the configured default", async () => {
+    const { deps } = makeDeps({ getConfiguredEffort: () => "medium" });
+    const r = await handleEffortCommand({ kind: "show" }, deps);
+    expect(r.text).toContain("medium");
+    expect(r.text).toMatch(/reverts to the configured default/);
+  });
+
+  it("show falls back to low when effort is unreadable", async () => {
+    const { deps } = makeDeps({ getConfiguredEffort: () => null });
+    const r = await handleEffortCommand({ kind: "show" }, deps);
+    expect(r.text).toContain("low");
+  });
+
+  it("set injects exactly '/effort <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(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") });
+    const r = await handleEffortCommand({ kind: "set", level: "max" }, deps);
+    expect(r.text).toContain("pane locked");
+    expect(r.text).toContain("❌");
+  });
+
+  it("set re-gates the level at the seam (defensive)", async () => {
+    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(r.text).toMatch(/not a valid effort level/);
+  });
+});
+
+describe("effort-command: menu + callback", () => {
+  it("buildEffortMenu offers all five levels with the configured one checked", () => {
+    const { deps } = makeDeps({ getConfiguredEffort: () => "high" });
+    const menu = buildEffortMenu(deps);
+    const buttons = menu.keyboard!.flat();
+    expect(buttons.map((b) => b.callback_data)).toEqual(
+      EFFORT_LEVELS.map((l) => effortSelectCallbackData(l)),
+    );
+    const checked = buttons.find((b) => b.text.startsWith("✅"));
+    expect(checked?.text).toBe("✅ high");
+    expect(menu.keyboard![0]).toHaveLength(5);
+  });
+
+  it("callback eff:s:<level> injects 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(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") });
+    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 ignores a malformed level", async () => {
+    const { deps, calls } = makeDeps();
+    const out = await handleEffortMenuCallback(`${EFFORT_CALLBACK_PREFIX}s:bogus`, deps);
+    expect(calls).toEqual([]);
+    expect(out.selectedEffort).toBeUndefined();
+  });
+});

package/telegram-plugin/tests/scoped-approval.test.ts

@@ -1,5 +1,5 @@
 /**
- * Tests for the "⏱ 30 min" scoped-approval tier (scoped-approval.ts) —
+ * Tests for scoped-approval.ts — the 30-min window backing the "Allow" tap
  * the middle rung between "Allow once" and "🔁 Always".
  *
  * These pin the access-model invariants the adversarial review flagged as
@@ -233,7 +233,7 @@ describe('isDestructiveBashCommand — fail-closed denylist', () => {
     recordScopedGrant(store, 'clerk', 'Bash(git:*)', T0, TTL)
     // first token is the harmless `git`, but the backtick hides `rm -rf`
     expect(lookupScopedGrant(store, 'clerk', 'Bash', bashInput('git status `rm -rf /important`'), T0 + 1)).toBeNull()
-    // and the request never gets offered the ⏱ button at grant time either
+    // and the request never gets a window at grant time either
     expect(timeBoxRule('Bash', bashInput('git status `rm -rf x`'))).toBeNull()
   })
 

package/telegram-plugin/welcome-text.ts

@@ -318,6 +318,10 @@ export const TELEGRAM_MENU_COMMANDS = [
   // same inject primitive as `/inject /model` but with a typed argument,
   // so it never opens the undriveable no-arg picker modal).
   { command: "model", description: "Show or switch the Claude model" },
+  // /effort — show or switch the reasoning effort (low→max, faster→smarter).
+  // Same Claude-native inject mechanism as /model; session-scoped, reverts
+  // to the configured `thinking_effort` default on restart.
+  { command: "effort", description: "Show or switch the reasoning effort" },
   { command: "doctor", description: "Health check (deps, services, MCP)" },
   { command: "usage", description: "Pro/Max plan quota (5h + 7d windows)" },
   // Vault — secrets + capability grants. /vault is a top-level command
@@ -379,6 +383,7 @@ export function switchroomHelpText(agentName: string): string {
     `<code>/auth rm [agent] &lt;slot&gt; [--force]</code> — remove a slot`,
     `<code>/model</code> — show the configured Claude model`,
     `<code>/model &lt;name&gt;</code> — switch the live session's model (opus · sonnet · haiku or a full id; until restart)`,
+    `<code>/effort</code> — show or switch reasoning effort (low · medium · high · xhigh · max; until restart)`,
     `<code>/topics</code> — topic-to-agent mappings`,
     `<code>/permissions [agent]</code> — show agent permissions`,
     `<code>/grant &lt;tool&gt;</code> — grant a tool permission`,