alvin-bot 4.18.0 → 4.18.2

package/test/registry.test.ts

@@ -1,201 +0,0 @@
-import { describe, it, expect, vi } from "vitest";
-import { ProviderRegistry } from "../src/providers/registry.js";
-import type { Provider, QueryOptions, StreamChunk } from "../src/providers/types.js";
-
-/**
- * Registry tests — focused on the queryWithFallback behaviour, which is
- * the core of today's reliability work:
- *   1. Silent retry on mid-stream transient aborts
- *   2. No mid-stream failover after visible text has already streamed
- *   3. Lifecycle boot on asleep providers
- *   4. Fallback chain traversal when providers are unavailable
- */
-
-// Mock provider factory — lets each test craft the exact chunk sequence
-function createMockProvider(opts: {
-  key?: string;
-  available?: boolean;
-  chunks: StreamChunk[];
-  attempts?: number[]; // per-attempt chunk sets (for retry tests)
-}): Provider {
-  let attemptIndex = 0;
-  return {
-    config: {
-      type: "openai-compatible",
-      name: opts.key || "mock",
-      model: "mock-model",
-    },
-    isAvailable: async () => opts.available ?? true,
-    getInfo: () => ({
-      name: opts.key || "mock",
-      model: "mock-model",
-      status: "mock",
-    }),
-    async *query(_options: QueryOptions): AsyncGenerator<StreamChunk> {
-      // If per-attempt sequences provided, use them in order
-      if (opts.attempts && opts.attempts.length > 0) {
-        const idx = Math.min(attemptIndex, opts.attempts.length - 1);
-        const count = opts.attempts[idx];
-        attemptIndex++;
-        for (let i = 0; i < count; i++) {
-          yield opts.chunks[i];
-        }
-      } else {
-        for (const c of opts.chunks) yield c;
-      }
-    },
-  };
-}
-
-describe("ProviderRegistry.queryWithFallback", () => {
-  it("yields chunks from the active provider on a happy path", async () => {
-    const provider = createMockProvider({
-      chunks: [
-        { type: "text", text: "hello world" },
-        { type: "done", text: "hello world", inputTokens: 10, outputTokens: 5 },
-      ],
-    });
-
-    const registry = new ProviderRegistry({
-      primary: "mock",
-      fallbacks: [],
-      providers: { mock: provider.config },
-    });
-    // Manually wire the mock provider — createProvider dispatches by type,
-    // which would create a real OpenAICompatibleProvider. We inject directly.
-    (registry as unknown as { providers: Map<string, Provider> }).providers.set("mock", provider);
-
-    const chunks: StreamChunk[] = [];
-    for await (const c of registry.queryWithFallback({ prompt: "hi" })) {
-      chunks.push(c);
-    }
-    expect(chunks.length).toBe(2);
-    expect(chunks[0]?.type).toBe("text");
-    expect(chunks[1]?.type).toBe("done");
-  });
-
-  it("falls back to the next provider when the active one has no visible text and errors", async () => {
-    const primary = createMockProvider({
-      chunks: [{ type: "error", error: "rate limit" }],
-    });
-    const fallback = createMockProvider({
-      chunks: [
-        { type: "text", text: "fallback answer" },
-        { type: "done", text: "fallback answer" },
-      ],
-    });
-
-    const registry = new ProviderRegistry({
-      primary: "primary",
-      fallbacks: ["fallback"],
-      providers: {
-        primary: primary.config,
-        fallback: fallback.config,
-      },
-    });
-    const internal = (registry as unknown as { providers: Map<string, Provider> }).providers;
-    internal.set("primary", primary);
-    internal.set("fallback", fallback);
-
-    const chunks: StreamChunk[] = [];
-    for await (const c of registry.queryWithFallback({ prompt: "hi" })) {
-      chunks.push(c);
-    }
-
-    // Expect: fallback chunk (switching notification), then text + done from fallback
-    const types = chunks.map((c) => c.type);
-    expect(types).toContain("fallback");
-    expect(types).toContain("text");
-    expect(types).toContain("done");
-  });
-
-  it("surfaces a terminal error (no fallback) when the active provider fails mid-stream", async () => {
-    const primary = createMockProvider({
-      chunks: [
-        { type: "text", text: "I'm starting the an" },
-        { type: "error", error: "Request aborted" },
-      ],
-    });
-    const fallback = createMockProvider({
-      chunks: [
-        { type: "text", text: "different answer" },
-        { type: "done", text: "different answer" },
-      ],
-    });
-
-    const registry = new ProviderRegistry({
-      primary: "primary",
-      fallbacks: ["fallback"],
-      providers: {
-        primary: primary.config,
-        fallback: fallback.config,
-      },
-    });
-    const internal = (registry as unknown as { providers: Map<string, Provider> }).providers;
-    internal.set("primary", primary);
-    internal.set("fallback", fallback);
-
-    const chunks: StreamChunk[] = [];
-    for await (const c of registry.queryWithFallback({ prompt: "hi" })) {
-      chunks.push(c);
-    }
-
-    // We SHOULD get the first text chunk (visible text)
-    // We SHOULD NOT get any fallback-provider chunks
-    // We SHOULD get a final error chunk with the "mid-stream" message
-    const texts = chunks.filter((c) => c.type === "text");
-    expect(texts.length).toBeGreaterThanOrEqual(1);
-    expect(texts.some((c) => c.text?.includes("different answer"))).toBe(false);
-
-    const errors = chunks.filter((c) => c.type === "error");
-    expect(errors.length).toBe(1);
-    // Mid-stream message is localised, just check it mentions the provider name
-    expect(errors[0]?.error).toContain("mock");
-  });
-
-  it("retries the SAME provider on mid-stream abort before giving up", async () => {
-    // First attempt: emits text then aborts mid-stream
-    // Second attempt: emits text and completes successfully
-    const querySpy = vi.fn();
-    let attemptCount = 0;
-    const provider: Provider = {
-      config: {
-        type: "openai-compatible",
-        name: "retry-test",
-        model: "m",
-      },
-      isAvailable: async () => true,
-      getInfo: () => ({ name: "retry-test", model: "m", status: "ok" }),
-      async *query() {
-        querySpy();
-        attemptCount++;
-        if (attemptCount === 1) {
-          yield { type: "text", text: "first partial" } as StreamChunk;
-          yield { type: "error", error: "Request aborted" } as StreamChunk;
-        } else {
-          yield { type: "text", text: "retry success" } as StreamChunk;
-          yield { type: "done", text: "retry success" } as StreamChunk;
-        }
-      },
-    };
-
-    const registry = new ProviderRegistry({
-      primary: "retry-test",
-      fallbacks: [],
-      providers: { "retry-test": provider.config },
-    });
-    (registry as unknown as { providers: Map<string, Provider> }).providers.set("retry-test", provider);
-
-    const chunks: StreamChunk[] = [];
-    for await (const c of registry.queryWithFallback({ prompt: "hi" })) {
-      chunks.push(c);
-    }
-
-    // query() should have been called twice — original attempt + 1 retry
-    expect(querySpy).toHaveBeenCalledTimes(2);
-    // The final done chunk should reflect the retry's success
-    const done = chunks.find((c) => c.type === "done");
-    expect(done).toBeDefined();
-    expect(done?.text).toBe("retry success");
-  }, 15_000); // allow for the 2s retry delay
-});

package/test/session-pending-background.test.ts

@@ -1,59 +0,0 @@
-/**
- * v4.12.3 — UserSession.pendingBackgroundCount
- *
- * When Claude launches an Agent/Task tool with run_in_background: true,
- * the SDK's CLI subprocess stays alive until the task-notification is
- * ready to deliver. During that window the main Telegram session is
- * effectively blocked — isProcessing=true, all new user messages get
- * queued. For 5-minute+ background tasks that's unacceptable UX.
- *
- * v4.12.3 tracks the count of pending background agents on each session
- * so the handler can detect the blocked state and bypass the SDK resume
- * (start a fresh SDK session for the new user message while the old
- * session drains in the background).
- *
- * The count is incremented by the message handler on async_launched
- * tool_result and decremented by the async-agent-watcher when it
- * delivers the sub-agent's result.
- */
-import { describe, it, expect, beforeEach, vi } from "vitest";
-
-beforeEach(() => vi.resetModules());
-
-describe("UserSession.pendingBackgroundCount (v4.12.3)", () => {
-  it("new session starts with pendingBackgroundCount=0", async () => {
-    const { getSession } = await import("../src/services/session.js");
-    const s = getSession("test-user-new");
-    expect(s.pendingBackgroundCount).toBe(0);
-  });
-
-  it("incrementing on the session persists across getSession calls", async () => {
-    const { getSession } = await import("../src/services/session.js");
-    const s1 = getSession("test-user-inc");
-    s1.pendingBackgroundCount = 2;
-    const s2 = getSession("test-user-inc");
-    expect(s2.pendingBackgroundCount).toBe(2);
-    expect(s1).toBe(s2);
-  });
-
-  it("resetSession zeroes pendingBackgroundCount", async () => {
-    const { getSession, resetSession } = await import("../src/services/session.js");
-    const s = getSession("test-user-reset");
-    s.pendingBackgroundCount = 3;
-    resetSession("test-user-reset");
-    expect(s.pendingBackgroundCount).toBe(0);
-  });
-
-  it("count can be decremented without going negative via explicit guard", async () => {
-    // The handler/watcher code is responsible for not decrementing below
-    // zero. This test just documents that the field is a plain number
-    // with no built-in guard — decrement logic lives in the consumers.
-    const { getSession } = await import("../src/services/session.js");
-    const s = getSession("test-user-dec");
-    s.pendingBackgroundCount = 1;
-    s.pendingBackgroundCount = Math.max(0, s.pendingBackgroundCount - 1);
-    expect(s.pendingBackgroundCount).toBe(0);
-    s.pendingBackgroundCount = Math.max(0, s.pendingBackgroundCount - 1);
-    expect(s.pendingBackgroundCount).toBe(0);
-  });
-});

package/test/session-persistence.test.ts

@@ -1,195 +0,0 @@
-/**
- * v4.11.0 — Session persistence across bot restarts.
- *
- * Sessions live in an in-memory Map that gets wiped on every bot restart.
- * This persistence layer flushes the Map to disk (debounced) and rehydrates
- * it on bot startup so Claude SDK's `resume: sessionId` keeps working,
- * conversation history survives, and user preferences (language, effort,
- * voiceReply) don't reset.
- */
-import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
-import fs from "fs";
-import os from "os";
-import { resolve } from "path";
-
-const TEST_DATA_DIR = resolve(os.tmpdir(), `alvin-session-persist-${process.pid}-${Date.now()}`);
-
-beforeEach(() => {
-  if (fs.existsSync(TEST_DATA_DIR)) fs.rmSync(TEST_DATA_DIR, { recursive: true, force: true });
-  fs.mkdirSync(TEST_DATA_DIR, { recursive: true });
-  process.env.ALVIN_DATA_DIR = TEST_DATA_DIR;
-  vi.resetModules();
-});
-
-afterEach(() => {
-  try { fs.rmSync(TEST_DATA_DIR, { recursive: true, force: true }); } catch { /* ignore */ }
-});
-
-describe("session-persistence (v4.11.0)", () => {
-  it("flushSessions writes a JSON file with all session fields that survive restart", async () => {
-    const sessionMod = await import("../src/services/session.js");
-    const persistMod = await import("../src/services/session-persistence.js");
-
-    const s = sessionMod.getSession("user-1");
-    s.sessionId = "sdk-abc-123";
-    s.language = "de";
-    s.effort = "high";
-    s.voiceReply = true;
-    s.workingDir = "/tmp/test-cwd";
-    s.history = [
-      { role: "user", content: "hi" },
-      { role: "assistant", content: "hello" },
-    ];
-
-    await persistMod.flushSessions();
-
-    const stateFile = resolve(TEST_DATA_DIR, "state", "sessions.json");
-    expect(fs.existsSync(stateFile)).toBe(true);
-
-    // v4.12.0 — Format is now an envelope: { version: 2, sessions: {...}, telegramWorkspaces: {...} }
-    const envelope = JSON.parse(fs.readFileSync(stateFile, "utf-8"));
-    expect(envelope.version).toBe(2);
-    const parsed = envelope.sessions;
-    expect(parsed).toHaveProperty("user-1");
-    expect(parsed["user-1"].sessionId).toBe("sdk-abc-123");
-    expect(parsed["user-1"].language).toBe("de");
-    expect(parsed["user-1"].effort).toBe("high");
-    expect(parsed["user-1"].voiceReply).toBe(true);
-    expect(parsed["user-1"].history).toHaveLength(2);
-  });
-
-  it("loadPersistedSessions rehydrates the sessions Map from disk", async () => {
-    fs.mkdirSync(resolve(TEST_DATA_DIR, "state"), { recursive: true });
-    fs.writeFileSync(
-      resolve(TEST_DATA_DIR, "state", "sessions.json"),
-      JSON.stringify({
-        "user-7": {
-          sessionId: "sdk-restored",
-          language: "en",
-          effort: "medium",
-          voiceReply: false,
-          workingDir: "/home/test",
-          lastActivity: Date.now() - 60_000,
-          lastSdkHistoryIndex: 3,
-          history: [{ role: "user", content: "from past life" }],
-          messageCount: 5,
-          toolUseCount: 2,
-        },
-      }),
-    );
-
-    const persistMod = await import("../src/services/session-persistence.js");
-    const sessionMod = await import("../src/services/session.js");
-
-    const loaded = persistMod.loadPersistedSessions();
-    expect(loaded).toBe(1);
-
-    const s = sessionMod.getSession("user-7");
-    expect(s.sessionId).toBe("sdk-restored");
-    expect(s.language).toBe("en");
-    expect(s.history).toHaveLength(1);
-    expect(s.history[0].content).toBe("from past life");
-    expect(s.messageCount).toBe(5);
-  });
-
-  it("survives a corrupt sessions.json file (does not crash)", async () => {
-    fs.mkdirSync(resolve(TEST_DATA_DIR, "state"), { recursive: true });
-    fs.writeFileSync(
-      resolve(TEST_DATA_DIR, "state", "sessions.json"),
-      "{ this is not valid json",
-    );
-
-    const persistMod = await import("../src/services/session-persistence.js");
-    const loaded = persistMod.loadPersistedSessions();
-    expect(loaded).toBe(0);
-  });
-
-  it("survives missing sessions.json file (returns 0 loaded)", async () => {
-    const persistMod = await import("../src/services/session-persistence.js");
-    const loaded = persistMod.loadPersistedSessions();
-    expect(loaded).toBe(0);
-  });
-
-  it("does NOT persist runtime-only fields (abortController, isProcessing)", async () => {
-    const sessionMod = await import("../src/services/session.js");
-    const persistMod = await import("../src/services/session-persistence.js");
-
-    const s = sessionMod.getSession("user-2");
-    s.isProcessing = true;
-    s.abortController = new AbortController();
-    s.sessionId = "abc";
-
-    await persistMod.flushSessions();
-
-    const stateFile = resolve(TEST_DATA_DIR, "state", "sessions.json");
-    const parsed = JSON.parse(fs.readFileSync(stateFile, "utf-8")).sessions;
-    expect(parsed["user-2"]).not.toHaveProperty("abortController");
-    expect(parsed["user-2"]).not.toHaveProperty("isProcessing");
-    expect(parsed["user-2"].sessionId).toBe("abc");
-  });
-
-  it("caps history at MAX_PERSISTED_HISTORY (50) so the file doesn't grow unbounded", async () => {
-    const sessionMod = await import("../src/services/session.js");
-    const persistMod = await import("../src/services/session-persistence.js");
-
-    const s = sessionMod.getSession("user-3");
-    s.sessionId = "needs-some-state-to-be-persisted";
-    for (let i = 0; i < 200; i++) {
-      s.history.push({ role: i % 2 === 0 ? "user" : "assistant", content: `msg ${i}` });
-    }
-
-    await persistMod.flushSessions();
-
-    const parsed = JSON.parse(fs.readFileSync(resolve(TEST_DATA_DIR, "state", "sessions.json"), "utf-8")).sessions;
-    expect(parsed["user-3"].history.length).toBeLessThanOrEqual(50);
-    // Last message should still be there
-    expect(parsed["user-3"].history.at(-1).content).toContain("199");
-  });
-
-  it("debounce: schedulePersist coalesces multiple rapid mutations into one flush", async () => {
-    const persistMod = await import("../src/services/session-persistence.js");
-    const sessionMod = await import("../src/services/session.js");
-
-    sessionMod.getSession("user-4").sessionId = "v1";
-    persistMod.schedulePersist();
-    sessionMod.getSession("user-4").sessionId = "v2";
-    persistMod.schedulePersist();
-    sessionMod.getSession("user-4").sessionId = "v3";
-    persistMod.schedulePersist();
-
-    // Force the debounced flush
-    await persistMod.flushSessions();
-
-    const parsed = JSON.parse(fs.readFileSync(resolve(TEST_DATA_DIR, "state", "sessions.json"), "utf-8")).sessions;
-    expect(parsed["user-4"].sessionId).toBe("v3");
-  });
-
-  it("atomic write: tmp+rename, never leaves a half-written file on crash", async () => {
-    const persistMod = await import("../src/services/session-persistence.js");
-    const sessionMod = await import("../src/services/session.js");
-
-    sessionMod.getSession("user-5").sessionId = "abc";
-    await persistMod.flushSessions();
-
-    // After successful flush: no .tmp leftover
-    const tmpFile = resolve(TEST_DATA_DIR, "state", "sessions.json.tmp");
-    expect(fs.existsSync(tmpFile)).toBe(false);
-    expect(fs.existsSync(resolve(TEST_DATA_DIR, "state", "sessions.json"))).toBe(true);
-  });
-
-  it("does not persist sessions that have never been activated (only defaults)", async () => {
-    const sessionMod = await import("../src/services/session.js");
-    const persistMod = await import("../src/services/session-persistence.js");
-
-    // Touching getSession creates an empty default session — but we don't want to
-    // persist it if it has no meaningful state (no sessionId, no history)
-    sessionMod.getSession("noop-user");
-    await persistMod.flushSessions();
-
-    const stateFile = resolve(TEST_DATA_DIR, "state", "sessions.json");
-    if (fs.existsSync(stateFile)) {
-      const parsed = JSON.parse(fs.readFileSync(stateFile, "utf-8")).sessions;
-      expect(parsed).not.toHaveProperty("noop-user");
-    }
-  });
-});

package/test/slack-progress-ticker.test.ts

@@ -1,123 +0,0 @@
-/**
- * v4.12.0 — Slack adapter editMessage support for progress tickers.
- *
- * Slack doesn't stream text like the OpenAI API does; the idiom is to
- * post an initial message, capture its `ts` (timestamp), then edit it
- * with growing content via chat.update. This mirrors Telegram's
- * editMessageText approach used in the cron progress ticker.
- */
-import { describe, it, expect, vi, beforeEach } from "vitest";
-
-beforeEach(() => {
-  vi.resetModules();
-});
-
-describe("SlackAdapter.editMessage (v4.12.0)", () => {
-  it("calls chat.update with the correct channel + ts when editMessage is invoked", async () => {
-    const updateSpy = vi.fn().mockResolvedValue({ ok: true, ts: "1234567890.123456" });
-    const postSpy = vi.fn().mockResolvedValue({ ok: true, ts: "1234567890.123456" });
-    const authSpy = vi.fn().mockResolvedValue({ ok: true, user_id: "U_BOT", user: "alvin", team: "Test" });
-
-    vi.doMock("@slack/bolt", () => ({
-      App: class {
-        client = {
-          auth: { test: authSpy },
-          chat: { postMessage: postSpy, update: updateSpy },
-          users: { info: vi.fn() },
-          reactions: { add: vi.fn() },
-          filesUploadV2: vi.fn(),
-          conversations: { info: vi.fn() },
-          apiCall: vi.fn(),
-        };
-        constructor(_opts: unknown) {}
-        message(_h: unknown) {}
-        event(_k: string, _h: unknown) {}
-        async start() {}
-        async stop() {}
-      },
-    }));
-
-    const { SlackAdapter } = await import("../src/platforms/slack.js");
-    const adapter = new SlackAdapter("xoxb-test", "xapp-test");
-    await adapter.start();
-
-    const returnedId = await adapter.editMessage!("C_TEST", "1234567890.123456", "updated text");
-    expect(updateSpy).toHaveBeenCalledWith(
-      expect.objectContaining({
-        channel: "C_TEST",
-        ts: "1234567890.123456",
-        text: "updated text",
-      }),
-    );
-    expect(returnedId).toBe("1234567890.123456");
-
-    await adapter.stop();
-  });
-
-  it("sendText returns the message ts so it can be edited later", async () => {
-    const postSpy = vi.fn().mockResolvedValue({ ok: true, ts: "9876543210.555555" });
-    const authSpy = vi.fn().mockResolvedValue({ ok: true, user_id: "U_BOT", user: "alvin", team: "Test" });
-
-    vi.doMock("@slack/bolt", () => ({
-      App: class {
-        client = {
-          auth: { test: authSpy },
-          chat: { postMessage: postSpy, update: vi.fn() },
-          users: { info: vi.fn() },
-          reactions: { add: vi.fn() },
-          filesUploadV2: vi.fn(),
-          conversations: { info: vi.fn() },
-          apiCall: vi.fn(),
-        };
-        constructor(_opts: unknown) {}
-        message(_h: unknown) {}
-        event(_k: string, _h: unknown) {}
-        async start() {}
-        async stop() {}
-      },
-    }));
-
-    const { SlackAdapter } = await import("../src/platforms/slack.js");
-    const adapter = new SlackAdapter("xoxb-test", "xapp-test");
-    await adapter.start();
-
-    const id = await adapter.sendText("C_TEST", "first message");
-    expect(id).toBe("9876543210.555555");
-
-    await adapter.stop();
-  });
-
-  it("editMessage returns messageId unchanged when chat.update fails", async () => {
-    const updateSpy = vi.fn().mockRejectedValue(new Error("slack down"));
-    const authSpy = vi.fn().mockResolvedValue({ ok: true, user_id: "U_BOT", user: "alvin", team: "Test" });
-
-    vi.doMock("@slack/bolt", () => ({
-      App: class {
-        client = {
-          auth: { test: authSpy },
-          chat: { postMessage: vi.fn().mockResolvedValue({ ok: true, ts: "x" }), update: updateSpy },
-          users: { info: vi.fn() },
-          reactions: { add: vi.fn() },
-          filesUploadV2: vi.fn(),
-          conversations: { info: vi.fn() },
-          apiCall: vi.fn(),
-        };
-        constructor(_opts: unknown) {}
-        message(_h: unknown) {}
-        event(_k: string, _h: unknown) {}
-        async start() {}
-        async stop() {}
-      },
-    }));
-
-    const { SlackAdapter } = await import("../src/platforms/slack.js");
-    const adapter = new SlackAdapter("xoxb-test", "xapp-test");
-    await adapter.start();
-
-    // Should not throw
-    const result = await adapter.editMessage!("C_TEST", "123.456", "new text");
-    expect(result).toBe("123.456");
-
-    await adapter.stop();
-  });
-});

package/test/slack-slash-command.test.ts

@@ -1,61 +0,0 @@
-/**
- * v4.13.2 — Slack slash command parser tests.
- *
- * Users on Slack type `/alvin <subcommand> [args...]` which Bolt
- * delivers via app.command('/alvin') with `command.text` containing
- * the part after `/alvin `. We parse it into a platform-agnostic
- * "/subcommand [args]" text that handlePlatformCommand already knows
- * how to route (/new, /status, /effort, /help).
- *
- * Empty text → `/help` (most helpful default).
- * Pass-through for everything else — unknown subcommand falls through
- * to normal LLM prompt handling.
- */
-import { describe, it, expect } from "vitest";
-import { parseSlackSlashCommand } from "../src/platforms/slack-slash-parser.js";
-
-describe("parseSlackSlashCommand (v4.13.2)", () => {
-  it("empty text maps to /help", () => {
-    expect(parseSlackSlashCommand("")).toBe("/help");
-    expect(parseSlackSlashCommand("   ")).toBe("/help");
-  });
-
-  it("single-word subcommand becomes /<subcommand>", () => {
-    expect(parseSlackSlashCommand("status")).toBe("/status");
-    expect(parseSlackSlashCommand("new")).toBe("/new");
-    expect(parseSlackSlashCommand("help")).toBe("/help");
-  });
-
-  it("subcommand with args preserves the args", () => {
-    expect(parseSlackSlashCommand("effort high")).toBe("/effort high");
-    expect(parseSlackSlashCommand("effort low")).toBe("/effort low");
-  });
-
-  it("multi-word args are preserved verbatim", () => {
-    expect(parseSlackSlashCommand("ask what is the weather in berlin")).toBe(
-      "/ask what is the weather in berlin",
-    );
-  });
-
-  it("collapses extra whitespace around subcommand", () => {
-    expect(parseSlackSlashCommand("   status   ")).toBe("/status");
-    expect(parseSlackSlashCommand("  effort    max   ")).toBe("/effort max");
-  });
-
-  it("lowercases the subcommand for case-insensitive matching", () => {
-    expect(parseSlackSlashCommand("Status")).toBe("/status");
-    expect(parseSlackSlashCommand("HELP")).toBe("/help");
-  });
-
-  it("does NOT lowercase the args (preserve user intent)", () => {
-    expect(parseSlackSlashCommand("ask What is THIS")).toBe(
-      "/ask What is THIS",
-    );
-  });
-
-  it("handles leading slash defensively — strips duplicate", () => {
-    // If a user literally types `/alvin /status`, Slack delivers text="/status"
-    expect(parseSlackSlashCommand("/status")).toBe("/status");
-    expect(parseSlackSlashCommand("/effort max")).toBe("/effort max");
-  });
-});