compass-agent 2.0.4

package/src/handlers/assistant.ts

@@ -0,0 +1,332 @@
+/**
+ * Slack Assistant handler — threadStarted + userMessage.
+ *
+ * Uses the Bolt Assistant class to intercept all IM thread messages,
+ * providing suggested prompts, thread titles, status indicators,
+ * and delegating to the stream handler for Claude invocations.
+ */
+
+import { Assistant } from "@slack/bolt";
+import { randomUUID } from "crypto";
+import {
+  getSession, upsertSession, setCwd, getCwdHistory, addCwdHistory,
+  addTeaching, getTeachings, removeTeaching, getTeachingCount,
+  getWorktree, touchWorktree, upsertWorktree, markWorktreeCleaned,
+} from "../db.ts";
+import {
+  detectGitRepo, createWorktree, copyEnvFiles,
+} from "../lib/worktree.ts";
+import { buildSuggestedPrompts } from "../ui/blocks.ts";
+import { handleClaudeStream } from "./stream.ts";
+import { log, logErr } from "../lib/log.ts";
+import type { ActiveProcessMap, Ref } from "../types.ts";
+
+const ALLOWED_USERS = new Set(
+  (process.env.ALLOWED_USERS || "").split(",").map((s) => s.trim()).filter(Boolean)
+);
+
+export function createAssistant(
+  activeProcesses: ActiveProcessMap,
+  cachedTeamIdRef: Ref<string | null>,
+  cachedBotUserIdRef: Ref<string | null>,
+): Assistant {
+  return new Assistant({
+    threadStarted: async ({ event, setSuggestedPrompts }: any) => {
+      const threadTs = event.assistant_thread?.thread_ts;
+      log(null, `Assistant threadStarted: thread=${threadTs}`);
+
+      const session = threadTs ? getSession(threadTs) : null;
+      try {
+        await setSuggestedPrompts(buildSuggestedPrompts(session?.cwd ?? null));
+      } catch (err: any) {
+        logErr(null, `Failed to set suggested prompts: ${err.message}`);
+      }
+    },
+
+    userMessage: async ({ message, client, say, setStatus, setTitle, setSuggestedPrompts }: any) => {
+      const channelId = message.channel;
+      const threadTs = message.thread_ts || message.ts;
+      const userText = message.text;
+
+      log(channelId, `Assistant userMessage: user=${message.user} ts=${message.ts} thread_ts=${threadTs} text="${userText}"`);
+
+      // ── Guards ──────────────────────────────────────────
+      if (message.subtype || message.bot_id) {
+        log(channelId, `Skipping: subtype=${message.subtype} bot_id=${message.bot_id}`);
+        return;
+      }
+
+      if (ALLOWED_USERS.size > 0 && !ALLOWED_USERS.has(message.user)) {
+        log(channelId, `Blocked unauthorized user=${message.user}`);
+        return;
+      }
+
+      // ── $cwd command ────────────────────────────────────
+      if (userText?.match(/^\$cwd(\s|$)/i)) {
+        const pathArg = userText.replace(/^\$cwd\s*/i, "").trim();
+
+        if (pathArg) {
+          if (!getSession(threadTs)) {
+            upsertSession(threadTs, "pending");
+          }
+          setCwd(threadTs, pathArg);
+          addCwdHistory(pathArg);
+          // Reset session so next message starts fresh (can't --resume in a different CWD)
+          upsertSession(threadTs, "pending");
+          markWorktreeCleaned(threadTs);
+          log(channelId, `CWD set via $cwd to: ${pathArg} (session reset)`);
+          try {
+            await client.chat.postEphemeral({
+              channel: channelId,
+              thread_ts: threadTs,
+              user: message.user,
+              text: `Working directory set to \`${pathArg}\``,
+            });
+            // Update suggested prompts with CWD context
+            await setSuggestedPrompts(buildSuggestedPrompts(pathArg));
+          } catch (err: any) {
+            logErr(channelId, `Failed to send CWD confirmation: ${err.message}`);
+          }
+          return;
+        }
+
+        // Bare $cwd — show interactive directory picker
+        const history = getCwdHistory();
+        log(channelId, `$cwd picker requested, history_count=${history.length}`);
+
+        const blocks: any[] = [
+          { type: "header", text: { type: "plain_text", text: "Set Working Directory" } },
+          { type: "divider" },
+        ];
+
+        if (history.length > 0) {
+          blocks.push(
+            { type: "section", text: { type: "mrkdwn", text: "*Recent directories:*" } },
+            {
+              type: "actions",
+              block_id: "cwd_picker_block",
+              elements: [{
+                type: "static_select",
+                action_id: "cwd_pick",
+                placeholder: { type: "plain_text", text: "Choose a directory..." },
+                options: history.map((h) => ({
+                  text: { type: "plain_text", text: h.path },
+                  value: JSON.stringify({ path: h.path, threadTs, isTopLevel: false }),
+                })),
+              }],
+            },
+            { type: "divider" },
+          );
+        }
+
+        blocks.push(
+          {
+            type: "section",
+            text: { type: "mrkdwn", text: "Enter a new path:" },
+            accessory: {
+              type: "button",
+              action_id: "cwd_add_new",
+              text: { type: "plain_text", text: "Add new..." },
+              style: "primary",
+              value: JSON.stringify({ channelId, threadTs }),
+            },
+          },
+          {
+            type: "context",
+            elements: [
+              { type: "mrkdwn", text: "Or send `$cwd /path/to/dir` to set directly" },
+            ],
+          },
+        );
+
+        try {
+          await client.chat.postEphemeral({
+            channel: channelId,
+            thread_ts: threadTs,
+            user: message.user,
+            blocks,
+            text: "Set working directory",
+          });
+          log(channelId, `$cwd picker sent (ephemeral to user=${message.user})`);
+        } catch (err: any) {
+          logErr(channelId, `Failed to send $cwd picker: ${err.message}`);
+        }
+        return;
+      }
+
+      // ── $teach command ──────────────────────────────────
+      if (userText?.match(/^\$teach(\s|$)/i)) {
+        const teachArg = userText.replace(/^\$teach\s*/i, "").trim();
+        log(channelId, `$teach command: arg="${teachArg || "(empty)"}" user=${message.user}`);
+
+        if (!teachArg || teachArg === "help") {
+          log(channelId, `$teach: showing help`);
+          try {
+            await client.chat.postMessage({
+              channel: channelId,
+              thread_ts: threadTs,
+              blocks: [
+                { type: "header", text: { type: "plain_text", text: "Team Knowledge Base" } },
+                { type: "divider" },
+                { type: "section", text: { type: "mrkdwn", text: "*Usage:*\n\u2022 `$teach <instruction>` \u2014 add a team convention\n\u2022 `$teach list` \u2014 view all active teachings\n\u2022 `$teach remove <id>` \u2014 remove a teaching by ID" } },
+                { type: "context", elements: [{ type: "mrkdwn", text: "Teachings are injected into every Claude session as team conventions." }] },
+              ],
+              text: "Team Knowledge Base help",
+            });
+          } catch (err: any) {
+            logErr(channelId, `$teach help: failed: ${err.message}`);
+          }
+          return;
+        }
+
+        if (teachArg === "list") {
+          const teachings = getTeachings("default");
+          log(channelId, `$teach list: ${teachings.length} active teachings`);
+          if (teachings.length === 0) {
+            try {
+              await say("No teachings yet. Add one with `$teach <instruction>`.");
+            } catch (err: any) {
+              logErr(channelId, `$teach list (empty): failed: ${err.message}`);
+            }
+            return;
+          }
+          const list = teachings.map((t) => `*#${t.id}* \u2014 ${t.instruction} _(added by <@${t.added_by}>)_`).join("\n");
+          try {
+            await client.chat.postMessage({
+              channel: channelId,
+              thread_ts: threadTs,
+              blocks: [
+                { type: "header", text: { type: "plain_text", text: "Team Teachings" } },
+                { type: "divider" },
+                { type: "section", text: { type: "mrkdwn", text: list } },
+                { type: "context", elements: [{ type: "mrkdwn", text: `${teachings.length} active teaching(s)` }] },
+              ],
+              text: `${teachings.length} teachings`,
+            });
+          } catch (err: any) {
+            logErr(channelId, `$teach list: failed: ${err.message}`);
+          }
+          return;
+        }
+
+        const removeMatch = teachArg.match(/^remove\s+(\d+)$/i);
+        if (removeMatch) {
+          const id = parseInt(removeMatch[1], 10);
+          log(channelId, `$teach remove: id=${id}`);
+          removeTeaching(id);
+          try {
+            await say(`Teaching #${id} removed.`);
+          } catch (err: any) {
+            logErr(channelId, `$teach remove: failed: ${err.message}`);
+          }
+          return;
+        }
+
+        // $teach <instruction>
+        const instruction = teachArg.replace(/^["']|["']$/g, "");
+        log(channelId, `$teach add: "${instruction}" user=${message.user}`);
+        addTeaching(instruction, message.user);
+        const count = getTeachingCount("default");
+        log(channelId, `$teach: now ${count.count} active teaching(s)`);
+        try {
+          await say(`Learned: _${instruction}_\n(${count.count} active teaching${count.count !== 1 ? "s" : ""})`);
+        } catch (err: any) {
+          logErr(channelId, `$teach add: failed: ${err.message}`);
+        }
+        return;
+      }
+
+      // ── Guard: already processing ─────────────────────
+      if (activeProcesses.has(threadTs)) {
+        const existing = activeProcesses.get(threadTs);
+        log(channelId, `Rejecting — already processing (pid=${existing?.pid})`);
+        await say("Still processing the previous message...");
+        return;
+      }
+
+      // ── Session lookup ────────────────────────────────
+      const session = getSession(threadTs);
+      let sessionId: string;
+      let isResume = false;
+
+      if (session && session.session_id && session.session_id !== "pending") {
+        sessionId = session.session_id;
+        isResume = true;
+        log(channelId, `Resuming session: ${sessionId}`);
+      } else {
+        sessionId = randomUUID();
+        if (!session) {
+          upsertSession(threadTs, "pending");
+        }
+        log(channelId, `New session: ${sessionId}`);
+      }
+
+      // ── CWD gate ──────────────────────────────────────
+      const currentSession = getSession(threadTs);
+      if (!currentSession?.cwd) {
+        log(channelId, `No CWD set, blocking`);
+        try {
+          await say("No working directory set. Send `$cwd` to pick one, or `$cwd /path/to/dir` to set directly.");
+          await setSuggestedPrompts(buildSuggestedPrompts(null));
+        } catch (err: any) {
+          logErr(channelId, `CWD gating: failed: ${err.message}`);
+        }
+        return;
+      }
+
+      // ── Set thread title from first message ───────────
+      if (!isResume) {
+        const titleText = userText.length > 60 ? userText.slice(0, 57) + "..." : userText;
+        try {
+          await setTitle(titleText);
+          log(channelId, `Thread title set: "${titleText}"`);
+        } catch (err: any) {
+          logErr(channelId, `Failed to set title: ${err.message}`);
+        }
+      }
+
+      // ── Worktree setup ────────────────────────────────
+      let spawnCwd = currentSession.cwd;
+      const existingWt = getWorktree(threadTs);
+      log(channelId, `Worktree lookup: thread=${threadTs} existingWt=${existingWt ? `path=${existingWt.worktree_path} cleaned=${existingWt.cleaned_up}` : "none"}`);
+
+      if (existingWt && !existingWt.cleaned_up) {
+        spawnCwd = existingWt.worktree_path;
+        touchWorktree(threadTs);
+        log(channelId, `Reusing worktree: ${spawnCwd}`);
+      } else {
+        const gitInfo = detectGitRepo(currentSession.cwd);
+        log(channelId, `Git detection: cwd=${currentSession.cwd} isGit=${gitInfo.isGit} repoRoot=${gitInfo.repoRoot}`);
+        if (gitInfo.isGit) {
+          try {
+            const { worktreePath, branchName } = createWorktree(gitInfo.repoRoot!, threadTs);
+            copyEnvFiles(currentSession.cwd, worktreePath);
+            upsertWorktree(threadTs, gitInfo.repoRoot!, worktreePath, branchName);
+            spawnCwd = worktreePath;
+            log(channelId, `Created worktree: ${worktreePath} branch=${branchName}`);
+          } catch (err: any) {
+            logErr(channelId, `Worktree creation failed, using raw CWD: ${err.message}`);
+          }
+        } else {
+          log(channelId, `Not a git repo, using raw CWD: ${spawnCwd}`);
+        }
+      }
+
+      // ── Delegate to stream handler ────────────────────
+      await handleClaudeStream({
+        channelId,
+        threadTs,
+        userText,
+        userId: message.user,
+        client,
+        spawnCwd: spawnCwd!,
+        isResume,
+        sessionId,
+        setStatus,
+        activeProcesses,
+        cachedTeamId: cachedTeamIdRef.value,
+        botUserId: cachedBotUserIdRef.value,
+      });
+    },
+  });
+}

package/src/handlers/cwd-modal.test.ts

@@ -0,0 +1,188 @@
+import { describe, it, expect, beforeEach, mock } from "bun:test";
+import { createCwdModalHandler } from "./cwd-modal.ts";
+
+function makeDeps(overrides = {}) {
+  return {
+    addCwdHistory: mock(() => {}),
+    setChannelDefault: mock(() => {}),
+    getSession: mock(() => null),
+    upsertSession: mock(() => {}),
+    setCwd: mock(() => {}),
+    markWorktreeCleaned: mock(() => {}),
+    ...overrides,
+  };
+}
+
+function makeView({ inputVal, selectVal, channelId = "C123", threadTs, isTopLevel = true }: {
+  inputVal?: string;
+  selectVal?: string;
+  channelId?: string;
+  threadTs?: string;
+  isTopLevel?: boolean;
+}) {
+  return {
+    private_metadata: JSON.stringify({ channelId, threadTs, isTopLevel }),
+    state: {
+      values: {
+        cwd_input_block: { cwd_input: { value: inputVal ?? null } },
+        cwd_select_block: { cwd_select: { selected_option: selectVal ? { value: selectVal } : null } },
+      },
+    },
+  };
+}
+
+function makeArgs(view: any, userId = "U456") {
+  return {
+    view,
+    ack: mock(() => Promise.resolve()),
+    client: { chat: { postEphemeral: mock(() => Promise.resolve({ ok: true })) } },
+    body: { user: { id: userId } },
+  };
+}
+
+describe("cwd_modal handler", () => {
+  it("uses body.user.id (not view.user) for postEphemeral", async () => {
+    const deps = makeDeps();
+    const handler = createCwdModalHandler(deps);
+    const view = makeView({ inputVal: "/projects/foo", isTopLevel: true });
+    const args = makeArgs(view, "U_REAL_USER");
+
+    await handler(args);
+
+    expect(args.client.chat.postEphemeral).toHaveBeenCalledWith(
+      expect.objectContaining({ user: "U_REAL_USER" }),
+    );
+  });
+
+  it("uses body.user.id for setChannelDefault on top-level", async () => {
+    const deps = makeDeps();
+    const handler = createCwdModalHandler(deps);
+    const view = makeView({ inputVal: "/code", isTopLevel: true });
+    const args = makeArgs(view, "U789");
+
+    await handler(args);
+
+    expect(deps.setChannelDefault).toHaveBeenCalledWith("C123", "/code", "U789");
+  });
+
+  it("returns validation error when no path is provided", async () => {
+    const deps = makeDeps();
+    const handler = createCwdModalHandler(deps);
+    const view = makeView({});
+    const args = makeArgs(view);
+
+    await handler(args);
+
+    expect(args.ack).toHaveBeenCalledWith({
+      response_action: "errors",
+      errors: { cwd_input_block: "Please enter a path or select one from the dropdown." },
+    });
+    expect(args.client.chat.postEphemeral).not.toHaveBeenCalled();
+  });
+
+  it("prefers text input over select", async () => {
+    const deps = makeDeps();
+    const handler = createCwdModalHandler(deps);
+    const view = makeView({ inputVal: "/typed/path", selectVal: "/selected/path", isTopLevel: true });
+    const args = makeArgs(view);
+
+    await handler(args);
+
+    expect(deps.addCwdHistory).toHaveBeenCalledWith("/typed/path");
+    expect(args.client.chat.postEphemeral).toHaveBeenCalledWith(
+      expect.objectContaining({ text: expect.stringContaining("/typed/path") }),
+    );
+  });
+
+  it("falls back to select value when input is empty", async () => {
+    const deps = makeDeps();
+    const handler = createCwdModalHandler(deps);
+    const view = makeView({ selectVal: "/selected/path", isTopLevel: true });
+    const args = makeArgs(view);
+
+    await handler(args);
+
+    expect(deps.addCwdHistory).toHaveBeenCalledWith("/selected/path");
+  });
+
+  it("sets thread CWD when top-level with threadTs", async () => {
+    const deps = makeDeps();
+    const handler = createCwdModalHandler(deps);
+    const view = makeView({ inputVal: "/code", isTopLevel: true, threadTs: "T100" });
+    const args = makeArgs(view);
+
+    await handler(args);
+
+    expect(deps.setChannelDefault).toHaveBeenCalled();
+    expect(deps.upsertSession).toHaveBeenCalledWith("T100", "pending");
+    expect(deps.setCwd).toHaveBeenCalledWith("T100", "/code");
+    expect(deps.markWorktreeCleaned).toHaveBeenCalledWith("T100");
+  });
+
+  it("uses threadTs as session key for non-top-level", async () => {
+    const deps = makeDeps();
+    const handler = createCwdModalHandler(deps);
+    const view = makeView({ inputVal: "/code", isTopLevel: false, threadTs: "T200" });
+    const args = makeArgs(view);
+
+    await handler(args);
+
+    expect(deps.setChannelDefault).not.toHaveBeenCalled();
+    expect(deps.setCwd).toHaveBeenCalledWith("T200", "/code");
+    expect(deps.markWorktreeCleaned).toHaveBeenCalledWith("T200");
+  });
+
+  it("falls back to channelId as session key when no threadTs", async () => {
+    const deps = makeDeps();
+    const handler = createCwdModalHandler(deps);
+    const view = makeView({ inputVal: "/code", isTopLevel: false, channelId: "C999" });
+    const args = makeArgs(view);
+
+    await handler(args);
+
+    expect(deps.setCwd).toHaveBeenCalledWith("C999", "/code");
+  });
+
+  it("skips upsertSession if session already exists", async () => {
+    const deps = makeDeps({ getSession: mock(() => ({ channel_id: "T300", session_id: "existing" })) });
+    const handler = createCwdModalHandler(deps);
+    const view = makeView({ inputVal: "/code", isTopLevel: false, threadTs: "T300" });
+    const args = makeArgs(view);
+
+    await handler(args);
+
+    // upsertSession should only be called once (the reset), not for initial creation
+    const calls = (deps.upsertSession as any).mock.calls;
+    expect(calls.length).toBe(1);
+    expect(calls[0]).toEqual(["T300", "pending"]);
+  });
+
+  it("sends ephemeral with correct channel and thread_ts", async () => {
+    const deps = makeDeps();
+    const handler = createCwdModalHandler(deps);
+    const view = makeView({ inputVal: "/code", isTopLevel: false, channelId: "C555", threadTs: "T555" });
+    const args = makeArgs(view, "U111");
+
+    await handler(args);
+
+    expect(args.client.chat.postEphemeral).toHaveBeenCalledWith({
+      channel: "C555",
+      thread_ts: "T555",
+      user: "U111",
+      text: "Working directory set to `/code`",
+    });
+  });
+
+  it("shows 'default for this channel' text for top-level", async () => {
+    const deps = makeDeps();
+    const handler = createCwdModalHandler(deps);
+    const view = makeView({ inputVal: "/code", isTopLevel: true });
+    const args = makeArgs(view);
+
+    await handler(args);
+
+    expect(args.client.chat.postEphemeral).toHaveBeenCalledWith(
+      expect.objectContaining({ text: expect.stringContaining("default for this channel") }),
+    );
+  });
+});

package/src/handlers/cwd-modal.ts

@@ -0,0 +1,63 @@
+import { log } from "../lib/log.ts";
+
+interface CwdModalDeps {
+  addCwdHistory: (path: string) => void;
+  setChannelDefault: (channelId: string, cwd: string, setBy: string) => void;
+  getSession: (key: string) => unknown;
+  upsertSession: (key: string, sessionId: string) => void;
+  setCwd: (key: string, cwd: string) => void;
+  markWorktreeCleaned: (key: string) => void;
+}
+
+export function createCwdModalHandler(deps: CwdModalDeps) {
+  return async ({ view, ack, client, body }: any) => {
+    const meta = JSON.parse(view.private_metadata);
+    const { channelId, threadTs, isTopLevel } = meta;
+    const values = view.state.values;
+
+    const inputVal = values.cwd_input_block?.cwd_input?.value;
+    const selectVal = values.cwd_select_block?.cwd_select?.selected_option?.value;
+    const chosenPath = inputVal || selectVal;
+
+    if (!chosenPath) {
+      await ack({
+        response_action: "errors",
+        errors: {
+          cwd_input_block: "Please enter a path or select one from the dropdown.",
+        },
+      });
+      return;
+    }
+
+    await ack();
+
+    deps.addCwdHistory(chosenPath);
+    if (isTopLevel) {
+      deps.setChannelDefault(channelId, chosenPath, body.user.id);
+      log(channelId, `Channel default CWD set to: ${chosenPath}`);
+      if (threadTs) {
+        if (!deps.getSession(threadTs)) deps.upsertSession(threadTs, "pending");
+        deps.setCwd(threadTs, chosenPath);
+        deps.upsertSession(threadTs, "pending");
+        deps.markWorktreeCleaned(threadTs);
+      }
+    } else {
+      const sessionKey = threadTs || channelId;
+      if (!deps.getSession(sessionKey)) deps.upsertSession(sessionKey, "pending");
+      deps.setCwd(sessionKey, chosenPath);
+      deps.upsertSession(sessionKey, "pending");
+      deps.markWorktreeCleaned(sessionKey);
+      log(channelId, `CWD set to: ${chosenPath} (thread=${threadTs}, session reset)`);
+    }
+
+    const confirmText = isTopLevel
+      ? `Working directory set to \`${chosenPath}\` (default for this channel)`
+      : `Working directory set to \`${chosenPath}\``;
+    await client.chat.postEphemeral({
+      channel: channelId,
+      thread_ts: threadTs,
+      user: body.user.id,
+      text: confirmText,
+    });
+  };
+}

package/src/handlers/setStatus.test.ts

@@ -0,0 +1,118 @@
+import { describe, test, expect, mock } from "bun:test";
+
+/**
+ * Tests for the setStatus wiring used in channel @mentions.
+ *
+ * The setStatus function built in app.ts processMessage normalizes
+ * string/object input and delegates to client.assistant.threads.setStatus.
+ * We recreate the same logic here to test it in isolation.
+ */
+
+function createChannelSetStatus(
+  client: any,
+  channelId: string,
+  threadTs: string,
+) {
+  return async (statusOrOpts: string | { status: string; loading_messages?: string[] }) => {
+    const params = typeof statusOrOpts === "string"
+      ? { status: statusOrOpts }
+      : statusOrOpts;
+    await client.assistant.threads.setStatus({
+      channel_id: channelId,
+      thread_ts: threadTs,
+      ...params,
+    });
+  };
+}
+
+describe("channel setStatus", () => {
+  test("string input — wraps as { status } and includes channel/thread", async () => {
+    const calls: any[] = [];
+    const client = {
+      assistant: {
+        threads: {
+          setStatus: mock(async (args: any) => { calls.push(args); }),
+        },
+      },
+    };
+
+    const setStatus = createChannelSetStatus(client, "C123", "1234.5678");
+    await setStatus("is reading files...");
+
+    expect(calls).toHaveLength(1);
+    expect(calls[0]).toEqual({
+      channel_id: "C123",
+      thread_ts: "1234.5678",
+      status: "is reading files...",
+    });
+  });
+
+  test("object input — spreads status + loading_messages with channel/thread", async () => {
+    const calls: any[] = [];
+    const client = {
+      assistant: {
+        threads: {
+          setStatus: mock(async (args: any) => { calls.push(args); }),
+        },
+      },
+    };
+
+    const setStatus = createChannelSetStatus(client, "C456", "9999.1111");
+    await setStatus({
+      status: "is thinking...",
+      loading_messages: ["Thinking...", "Working on it..."],
+    });
+
+    expect(calls).toHaveLength(1);
+    expect(calls[0]).toEqual({
+      channel_id: "C456",
+      thread_ts: "9999.1111",
+      status: "is thinking...",
+      loading_messages: ["Thinking...", "Working on it..."],
+    });
+  });
+
+  test("empty string clears status", async () => {
+    const calls: any[] = [];
+    const client = {
+      assistant: {
+        threads: {
+          setStatus: mock(async (args: any) => { calls.push(args); }),
+        },
+      },
+    };
+
+    const setStatus = createChannelSetStatus(client, "C789", "5555.6666");
+    await setStatus("");
+
+    expect(calls).toHaveLength(1);
+    expect(calls[0]).toEqual({
+      channel_id: "C789",
+      thread_ts: "5555.6666",
+      status: "",
+    });
+  });
+
+  test("multiple calls accumulate correctly", async () => {
+    const calls: any[] = [];
+    const client = {
+      assistant: {
+        threads: {
+          setStatus: mock(async (args: any) => { calls.push(args); }),
+        },
+      },
+    };
+
+    const setStatus = createChannelSetStatus(client, "C100", "1111.2222");
+    await setStatus({ status: "is thinking...", loading_messages: ["Thinking..."] });
+    await setStatus("is reading files...");
+    await setStatus("");
+
+    expect(calls).toHaveLength(3);
+    expect(calls[0].status).toBe("is thinking...");
+    expect(calls[0].loading_messages).toEqual(["Thinking..."]);
+    expect(calls[1].status).toBe("is reading files...");
+    expect(calls[1].loading_messages).toBeUndefined();
+    expect(calls[2].status).toBe("");
+  });
+});