compass-agent 2.0.4

package/src/ui/blocks.ts

@@ -0,0 +1,155 @@
+import {
+  getAllActiveSessions, getTeachings, getActiveWorktrees, getRecentUsage,
+} from "../db.ts";
+import type { ActiveProcessMap } from "../types.ts";
+
+export function buildBlocks(text: string, threadKey: string, showStop: boolean): any[] {
+  const blocks: any[] = [
+    { type: "section", text: { type: "mrkdwn", text: text || " " } },
+  ];
+  if (showStop) {
+    blocks.push({
+      type: "actions",
+      elements: [
+        {
+          type: "button",
+          text: { type: "plain_text", text: "Stop" },
+          style: "danger",
+          action_id: "stop_claude",
+          value: threadKey,
+        },
+      ],
+    });
+  }
+  return blocks;
+}
+
+export function buildStopOnlyBlocks(threadKey: string): any[] {
+  return [{
+    type: "actions",
+    elements: [{
+      type: "button",
+      text: { type: "plain_text", text: "Stop" },
+      style: "danger",
+      action_id: "stop_claude",
+      value: threadKey,
+    }],
+  }];
+}
+
+export function buildFeedbackBlock(sessionKey: string): any {
+  return {
+    type: "context_actions",
+    elements: [{
+      type: "feedback_buttons",
+      action_id: "response_feedback",
+      positive_button: {
+        text: { type: "plain_text", text: "\ud83d\udc4d" },
+        value: `positive:${sessionKey}`,
+      },
+      negative_button: {
+        text: { type: "plain_text", text: "\ud83d\udc4e" },
+        value: `negative:${sessionKey}`,
+      },
+    }],
+  };
+}
+
+export function buildDisclaimerBlock(): any {
+  return {
+    type: "context",
+    elements: [{
+      type: "mrkdwn",
+      text: "Generated by Claude. Verify important information.",
+    }],
+  };
+}
+
+export function buildSuggestedPrompts(cwd: string | null): { prompts: any[]; title: string } {
+  return {
+    prompts: [
+      {
+        title: "Set working directory",
+        message: "$cwd",
+      },
+      {
+        title: "Explain this codebase",
+        message: "Give me a high-level overview of this project's architecture, key files, and how the code is organized.",
+      },
+      {
+        title: "Find and fix bugs",
+        message: "Look for potential bugs, race conditions, or error-handling issues in the codebase and suggest fixes.",
+      },
+      {
+        title: "Write tests",
+        message: "Identify code lacking test coverage and write comprehensive tests for the most critical paths.",
+      },
+    ],
+    title: cwd ? `Working in ${cwd}` : "What would you like to do?",
+  };
+}
+
+export function buildHomeBlocks(activeProcesses: ActiveProcessMap): any[] {
+  const sessions = getAllActiveSessions();
+  const teachings = getTeachings("default");
+  const worktrees = getActiveWorktrees();
+  const recentUsage = getRecentUsage(5);
+
+  const blocks: any[] = [
+    { type: "header", text: { type: "plain_text", text: "Claude Code Dashboard" } },
+    { type: "context", elements: [{ type: "mrkdwn", text: `Last updated: ${new Date().toLocaleString()}` }] },
+    { type: "divider" },
+    { type: "section", fields: [
+      { type: "mrkdwn", text: `*Active Sessions:*\n${sessions.length}` },
+      { type: "mrkdwn", text: `*Team Teachings:*\n${teachings.length}` },
+      { type: "mrkdwn", text: `*Active Worktrees:*\n${worktrees.length}` },
+      { type: "mrkdwn", text: `*Running Processes:*\n${activeProcesses.size}` },
+    ]},
+    { type: "divider" },
+  ];
+
+  if (sessions.length > 0) {
+    blocks.push({ type: "header", text: { type: "plain_text", text: "Recent Sessions" } });
+    for (const s of sessions.slice(0, 10)) {
+      const statusIcon = activeProcesses.has(s.channel_id) ? ":large_green_circle:" : ":white_circle:";
+      blocks.push({
+        type: "section",
+        text: { type: "mrkdwn", text: `${statusIcon} \`${s.cwd || "no cwd"}\`\n_Updated: ${s.updated_at}_` },
+      });
+    }
+    blocks.push({ type: "divider" });
+  }
+
+  if (recentUsage.length > 0) {
+    blocks.push({ type: "header", text: { type: "plain_text", text: "Recent Activity" } });
+    for (const u of recentUsage) {
+      blocks.push({
+        type: "section",
+        text: { type: "mrkdwn", text: `*${u.model || "claude"}* \u2014 ${u.num_turns} turn(s), $${(u.total_cost_usd || 0).toFixed(4)} \u2014 _${u.created_at}_` },
+      });
+    }
+    blocks.push({ type: "divider" });
+  }
+
+  blocks.push(
+    { type: "header", text: { type: "plain_text", text: "Quick Actions" } },
+    {
+      type: "actions",
+      elements: [
+        {
+          type: "button",
+          text: { type: "plain_text", text: "View Teachings" },
+          action_id: "home_view_teachings",
+        },
+        {
+          type: "button",
+          text: { type: "plain_text", text: "Add Teaching" },
+          action_id: "home_add_teaching",
+          style: "primary",
+        },
+      ],
+    }
+  );
+
+  return blocks;
+}

package/tests/blocks.test.ts

@@ -0,0 +1,73 @@
+import { describe, test, expect } from "bun:test";
+import {
+  buildBlocks, buildStopOnlyBlocks, buildFeedbackBlock,
+  buildDisclaimerBlock, buildSuggestedPrompts,
+} from "../src/ui/blocks.ts";
+
+describe("buildBlocks", () => {
+  test("renders text section without stop button", () => {
+    const blocks = buildBlocks("Hello world", "thread-1", false);
+    expect(blocks.length).toBe(1);
+    expect(blocks[0].type).toBe("section");
+    expect(blocks[0].text.text).toBe("Hello world");
+  });
+
+  test("renders text section with stop button", () => {
+    const blocks = buildBlocks("Hello", "thread-1", true);
+    expect(blocks.length).toBe(2);
+    expect(blocks[1].type).toBe("actions");
+    expect(blocks[1].elements[0].action_id).toBe("stop_claude");
+    expect(blocks[1].elements[0].value).toBe("thread-1");
+  });
+
+  test("uses space for empty text", () => {
+    const blocks = buildBlocks("", "thread-1", false);
+    expect(blocks[0].text.text).toBe(" ");
+  });
+});
+
+describe("buildStopOnlyBlocks", () => {
+  test("returns actions block with stop button", () => {
+    const blocks = buildStopOnlyBlocks("thread-1");
+    expect(blocks.length).toBe(1);
+    expect(blocks[0].type).toBe("actions");
+    expect(blocks[0].elements[0].style).toBe("danger");
+    expect(blocks[0].elements[0].value).toBe("thread-1");
+  });
+});
+
+describe("buildFeedbackBlock", () => {
+  test("returns context_actions with feedback buttons", () => {
+    const block = buildFeedbackBlock("sess-1");
+    expect(block.type).toBe("context_actions");
+    expect(block.elements[0].positive_button.value).toBe("positive:sess-1");
+    expect(block.elements[0].negative_button.value).toBe("negative:sess-1");
+  });
+});
+
+describe("buildDisclaimerBlock", () => {
+  test("returns context block with disclaimer text", () => {
+    const block = buildDisclaimerBlock();
+    expect(block.type).toBe("context");
+    expect(block.elements[0].text).toContain("Verify important information");
+  });
+});
+
+describe("buildSuggestedPrompts", () => {
+  test("includes 4 prompts", () => {
+    const { prompts } = buildSuggestedPrompts(null);
+    expect(prompts.length).toBe(4);
+    expect(prompts[0].title).toBeDefined();
+    expect(prompts[0].message).toBeDefined();
+  });
+
+  test("title includes cwd when provided", () => {
+    const { title } = buildSuggestedPrompts("/home/project");
+    expect(title).toContain("/home/project");
+  });
+
+  test("title uses default when cwd is null", () => {
+    const { title } = buildSuggestedPrompts(null);
+    expect(title).toBe("What would you like to do?");
+  });
+});

package/tests/db.test.ts

@@ -0,0 +1,261 @@
+import { describe, test, expect, beforeEach } from "bun:test";
+import { createDatabase } from "../src/db.ts";
+
+function freshDb() {
+  return createDatabase(":memory:");
+}
+
+describe("sessions", () => {
+  let db: ReturnType<typeof createDatabase>;
+  beforeEach(() => { db = freshDb(); });
+
+  test("getSession returns null for unknown channel", () => {
+    expect(db.getSession("C999")).toBeNull();
+  });
+
+  test("upsertSession creates and retrieves a session", () => {
+    db.upsertSession("C1", "sess-abc");
+    const s = db.getSession("C1");
+    expect(s).not.toBeNull();
+    expect(s!.channel_id).toBe("C1");
+    expect(s!.session_id).toBe("sess-abc");
+    expect(s!.persisted).toBe(0);
+  });
+
+  test("upsertSession updates existing session", () => {
+    db.upsertSession("C1", "sess-1");
+    db.upsertSession("C1", "sess-2");
+    const s = db.getSession("C1");
+    expect(s!.session_id).toBe("sess-2");
+    expect(s!.persisted).toBe(0);
+  });
+
+  test("markPersisted sets persisted flag", () => {
+    db.upsertSession("C1", "sess-1");
+    db.markPersisted("C1");
+    expect(db.getSession("C1")!.persisted).toBe(1);
+  });
+
+  test("upsert after markPersisted resets persisted to 0", () => {
+    db.upsertSession("C1", "sess-1");
+    db.markPersisted("C1");
+    db.upsertSession("C1", "sess-2");
+    expect(db.getSession("C1")!.persisted).toBe(0);
+  });
+
+  test("deleteSession removes session", () => {
+    db.upsertSession("C1", "sess-1");
+    db.deleteSession("C1");
+    expect(db.getSession("C1")).toBeNull();
+  });
+
+  test("setCwd updates session cwd", () => {
+    db.upsertSession("C1", "sess-1");
+    db.setCwd("C1", "/home/project");
+    expect(db.getSession("C1")!.cwd).toBe("/home/project");
+  });
+
+  test("getAllActiveSessions returns sessions ordered by updated_at", () => {
+    db.upsertSession("C1", "s1");
+    db.upsertSession("C2", "s2");
+    db.upsertSession("C3", "s3");
+    const all = db.getAllActiveSessions();
+    expect(all.length).toBe(3);
+  });
+});
+
+describe("cwd_history", () => {
+  let db: ReturnType<typeof createDatabase>;
+  beforeEach(() => { db = freshDb(); });
+
+  test("getCwdHistory is empty initially", () => {
+    expect(db.getCwdHistory()).toEqual([]);
+  });
+
+  test("addCwdHistory adds and retrieves path", () => {
+    db.addCwdHistory("/home/project");
+    const history = db.getCwdHistory();
+    expect(history.length).toBe(1);
+    expect(history[0].path).toBe("/home/project");
+  });
+
+  test("addCwdHistory upserts on duplicate path", () => {
+    db.addCwdHistory("/home/project");
+    db.addCwdHistory("/home/project");
+    expect(db.getCwdHistory().length).toBe(1);
+  });
+});
+
+describe("channel_defaults", () => {
+  let db: ReturnType<typeof createDatabase>;
+  beforeEach(() => { db = freshDb(); });
+
+  test("getChannelDefault returns null for unknown channel", () => {
+    expect(db.getChannelDefault("C999")).toBeNull();
+  });
+
+  test("setChannelDefault creates and retrieves default", () => {
+    db.setChannelDefault("C1", "/home/project", "U1");
+    const d = db.getChannelDefault("C1");
+    expect(d!.cwd).toBe("/home/project");
+    expect(d!.set_by).toBe("U1");
+  });
+
+  test("setChannelDefault upserts on conflict", () => {
+    db.setChannelDefault("C1", "/old", "U1");
+    db.setChannelDefault("C1", "/new", "U2");
+    const d = db.getChannelDefault("C1");
+    expect(d!.cwd).toBe("/new");
+    expect(d!.set_by).toBe("U2");
+  });
+});
+
+describe("teachings", () => {
+  let db: ReturnType<typeof createDatabase>;
+  beforeEach(() => { db = freshDb(); });
+
+  test("getTeachings returns empty for fresh db", () => {
+    expect(db.getTeachings()).toEqual([]);
+  });
+
+  test("addTeaching + getTeachings round-trip", () => {
+    db.addTeaching("Use bun not node", "U1");
+    db.addTeaching("Always test", "U2");
+    const teachings = db.getTeachings();
+    expect(teachings.length).toBe(2);
+    expect(teachings[0].instruction).toBe("Use bun not node");
+    expect(teachings[1].instruction).toBe("Always test");
+  });
+
+  test("removeTeaching soft-deletes", () => {
+    db.addTeaching("Remove me", "U1");
+    const id = db.getTeachings()[0].id;
+    db.removeTeaching(id);
+    expect(db.getTeachings()).toEqual([]);
+  });
+
+  test("getTeachingCount reflects active teachings", () => {
+    expect(db.getTeachingCount().count).toBe(0);
+    db.addTeaching("one", "U1");
+    db.addTeaching("two", "U1");
+    expect(db.getTeachingCount().count).toBe(2);
+    db.removeTeaching(db.getTeachings()[0].id);
+    expect(db.getTeachingCount().count).toBe(1);
+  });
+
+  test("teachings are scoped by workspace_id", () => {
+    db.addTeaching("default teaching", "U1", "default");
+    db.addTeaching("team teaching", "U1", "team-a");
+    expect(db.getTeachings("default").length).toBe(1);
+    expect(db.getTeachings("team-a").length).toBe(1);
+    expect(db.getTeachings("team-b").length).toBe(0);
+  });
+});
+
+describe("usage_logs", () => {
+  let db: ReturnType<typeof createDatabase>;
+  beforeEach(() => { db = freshDb(); });
+
+  test("getRecentUsage returns empty initially", () => {
+    expect(db.getRecentUsage()).toEqual([]);
+  });
+
+  test("addUsageLog + getRecentUsage round-trip", () => {
+    db.addUsageLog("thread-1", "U1", "claude-3", 100, 200, 0.05, 1000, 3);
+    const logs = db.getRecentUsage();
+    expect(logs.length).toBe(1);
+    expect(logs[0].session_key).toBe("thread-1");
+    expect(logs[0].input_tokens).toBe(100);
+    expect(logs[0].output_tokens).toBe(200);
+    expect(logs[0].total_cost_usd).toBeCloseTo(0.05);
+    expect(logs[0].num_turns).toBe(3);
+  });
+
+  test("getRecentUsage respects limit", () => {
+    for (let i = 0; i < 5; i++) {
+      db.addUsageLog(`t-${i}`, "U1", "claude-3", 10, 20, 0.01, 100, 1);
+    }
+    expect(db.getRecentUsage(3).length).toBe(3);
+    expect(db.getRecentUsage(10).length).toBe(5);
+  });
+});
+
+describe("worktrees", () => {
+  let db: ReturnType<typeof createDatabase>;
+  beforeEach(() => { db = freshDb(); });
+
+  test("getWorktree returns null for unknown session", () => {
+    expect(db.getWorktree("unknown")).toBeNull();
+  });
+
+  test("upsertWorktree creates and retrieves worktree", () => {
+    db.upsertWorktree("thread-1", "/repo", "/repo/trees/branch", "slack/branch");
+    const wt = db.getWorktree("thread-1");
+    expect(wt!.repo_path).toBe("/repo");
+    expect(wt!.worktree_path).toBe("/repo/trees/branch");
+    expect(wt!.branch_name).toBe("slack/branch");
+    expect(wt!.cleaned_up).toBe(0);
+  });
+
+  test("upsertWorktree updates existing and resets cleaned_up", () => {
+    db.upsertWorktree("thread-1", "/repo", "/old", "old-branch");
+    db.markWorktreeCleaned("thread-1");
+    expect(db.getWorktree("thread-1")!.cleaned_up).toBe(1);
+
+    db.upsertWorktree("thread-1", "/repo", "/new", "new-branch");
+    const wt = db.getWorktree("thread-1");
+    expect(wt!.worktree_path).toBe("/new");
+    expect(wt!.cleaned_up).toBe(0);
+  });
+
+  test("getActiveWorktrees excludes cleaned up", () => {
+    db.upsertWorktree("t1", "/r", "/w1", "b1");
+    db.upsertWorktree("t2", "/r", "/w2", "b2");
+    db.markWorktreeCleaned("t1");
+    const active = db.getActiveWorktrees();
+    expect(active.length).toBe(1);
+    expect(active[0].session_key).toBe("t2");
+  });
+});
+
+describe("feedback", () => {
+  let db: ReturnType<typeof createDatabase>;
+  beforeEach(() => { db = freshDb(); });
+
+  test("addFeedback inserts without error", () => {
+    expect(() => {
+      db.addFeedback("thread-1", "U1", "positive", "1234.5678");
+    }).not.toThrow();
+  });
+});
+
+describe("reminders", () => {
+  let db: ReturnType<typeof createDatabase>;
+  beforeEach(() => { db = freshDb(); });
+
+  test("getActiveReminders returns empty initially", () => {
+    expect(db.getActiveReminders("U1")).toEqual([]);
+  });
+
+  test("addReminder + getActiveReminders round-trip", () => {
+    db.addReminder("C1", "U1", "B1", "standup", "remind standup", "0 9 * * *", 0, "2025-01-01 09:00:00");
+    const reminders = db.getActiveReminders("U1");
+    expect(reminders.length).toBe(1);
+    expect(reminders[0].content).toBe("standup");
+    expect(reminders[0].cron_expression).toBe("0 9 * * *");
+  });
+
+  test("deactivateReminder hides from active list", () => {
+    db.addReminder("C1", "U1", "B1", "test", "test", null, 1, "2025-01-01 09:00:00");
+    const id = db.getActiveReminders("U1")[0].id;
+    db.deactivateReminder(id);
+    expect(db.getActiveReminders("U1")).toEqual([]);
+  });
+
+  test("updateNextTrigger changes trigger time", () => {
+    db.addReminder("C1", "U1", "B1", "test", "test", "0 9 * * *", 0, "2025-01-01 09:00:00");
+    const id = db.getActiveReminders("U1")[0].id;
+    db.updateNextTrigger("2025-01-02 09:00:00", id);
+    expect(db.getActiveReminders("U1")[0].next_trigger_at).toBe("2025-01-02 09:00:00");
+  });
+});

package/tests/thread-context.test.ts

@@ -0,0 +1,183 @@
+import { describe, test, expect } from "bun:test";
+import { extractGapMessages, formatGapMessages, type ThreadMessage } from "../src/lib/thread-context.ts";
+
+const BOT_USER_ID = "U_BOT";
+
+function msg(user: string, text: string, ts: string, extra?: Partial<ThreadMessage>): ThreadMessage {
+  return { user, text, ts, ...extra };
+}
+
+describe("extractGapMessages", () => {
+  test("returns gap messages after bot's last reply", () => {
+    const messages: ThreadMessage[] = [
+      msg("U1", "Let's refactor auth", "1.0"),
+      msg(BOT_USER_ID, "Sure, here's my suggestion", "2.0"),
+      msg("U2", "What about JWT?", "3.0"),
+      msg("U3", "Yeah JWT makes sense", "4.0"),
+      msg("U1", "@bot thoughts on JWT?", "5.0"),
+    ];
+
+    const gap = extractGapMessages(messages, "5.0", BOT_USER_ID);
+    expect(gap).toHaveLength(2);
+    expect(gap[0].text).toBe("What about JWT?");
+    expect(gap[1].text).toBe("Yeah JWT makes sense");
+  });
+
+  test("returns up to 50 messages when no bot message exists", () => {
+    const messages: ThreadMessage[] = [
+      msg("U1", "Let's discuss the deploy", "1.0"),
+      msg("U2", "I think staging is broken", "2.0"),
+      msg("U3", "Let me check", "3.0"),
+      msg("U1", "@bot can you help?", "4.0"),
+    ];
+
+    const gap = extractGapMessages(messages, "4.0", BOT_USER_ID);
+    expect(gap).toHaveLength(3);
+    expect(gap[0].text).toBe("Let's discuss the deploy");
+    expect(gap[1].text).toBe("I think staging is broken");
+    expect(gap[2].text).toBe("Let me check");
+  });
+
+  test("returns empty when bot message is right before the mention", () => {
+    const messages: ThreadMessage[] = [
+      msg("U1", "Hey", "1.0"),
+      msg(BOT_USER_ID, "Hello!", "2.0"),
+      msg("U1", "@bot do more", "3.0"),
+    ];
+
+    const gap = extractGapMessages(messages, "3.0", BOT_USER_ID);
+    expect(gap).toHaveLength(0);
+  });
+
+  test("stops at the most recent bot message when multiple exist", () => {
+    const messages: ThreadMessage[] = [
+      msg("U1", "First question", "1.0"),
+      msg(BOT_USER_ID, "First answer", "2.0"),
+      msg("U2", "Follow up", "3.0"),
+      msg(BOT_USER_ID, "Second answer", "4.0"),
+      msg("U3", "Another topic", "5.0"),
+      msg("U1", "@bot help", "6.0"),
+    ];
+
+    const gap = extractGapMessages(messages, "6.0", BOT_USER_ID);
+    expect(gap).toHaveLength(1);
+    expect(gap[0].text).toBe("Another topic");
+  });
+
+  test("caps at 50 gap messages", () => {
+    const messages: ThreadMessage[] = [];
+    for (let i = 0; i < 60; i++) {
+      messages.push(msg("U1", `Message ${i}`, `${i}.0`));
+    }
+    messages.push(msg("U1", "@bot help", "100.0"));
+
+    const gap = extractGapMessages(messages, "100.0", BOT_USER_ID);
+    expect(gap).toHaveLength(50);
+    // Should be the last 50 messages (indices 10-59)
+    expect(gap[0].text).toBe("Message 10");
+    expect(gap[49].text).toBe("Message 59");
+  });
+
+  test("excludes the current mention message", () => {
+    const messages: ThreadMessage[] = [
+      msg("U1", "Hey", "1.0"),
+      msg("U1", "@bot help me", "2.0"),
+    ];
+
+    const gap = extractGapMessages(messages, "2.0", BOT_USER_ID);
+    expect(gap).toHaveLength(1);
+    expect(gap[0].text).toBe("Hey");
+    // The mention itself should not appear
+    expect(gap.find((m) => m.ts === "2.0")).toBeUndefined();
+  });
+
+  test("identifies bot by bot_id field", () => {
+    const messages: ThreadMessage[] = [
+      msg("U1", "Start", "1.0"),
+      msg("U_OTHER", "Bot reply", "2.0", { bot_id: "B123" }),
+      msg("U2", "After bot", "3.0"),
+      msg("U1", "@bot hi", "4.0"),
+    ];
+
+    const gap = extractGapMessages(messages, "4.0", BOT_USER_ID);
+    expect(gap).toHaveLength(1);
+    expect(gap[0].text).toBe("After bot");
+  });
+
+  test("identifies bot by user field matching botUserId", () => {
+    const messages: ThreadMessage[] = [
+      msg("U1", "Before", "1.0"),
+      msg(BOT_USER_ID, "Bot says hi", "2.0"),
+      msg("U2", "After", "3.0"),
+      msg("U1", "@bot yo", "4.0"),
+    ];
+
+    const gap = extractGapMessages(messages, "4.0", BOT_USER_ID);
+    expect(gap).toHaveLength(1);
+    expect(gap[0].text).toBe("After");
+  });
+
+  test("returns empty for empty messages array", () => {
+    const gap = extractGapMessages([], "1.0", BOT_USER_ID);
+    expect(gap).toHaveLength(0);
+  });
+
+  test("returns empty when thread has only the mention", () => {
+    const messages: ThreadMessage[] = [
+      msg("U1", "@bot help", "1.0"),
+    ];
+
+    const gap = extractGapMessages(messages, "1.0", BOT_USER_ID);
+    expect(gap).toHaveLength(0);
+  });
+
+  test("works when botUserId is null (uses bot_id only)", () => {
+    const messages: ThreadMessage[] = [
+      msg("U1", "Start", "1.0"),
+      msg("U_ANY", "Bot reply", "2.0", { bot_id: "B456" }),
+      msg("U2", "Gap msg", "3.0"),
+      msg("U1", "@bot hi", "4.0"),
+    ];
+
+    const gap = extractGapMessages(messages, "4.0", null);
+    expect(gap).toHaveLength(1);
+    expect(gap[0].text).toBe("Gap msg");
+  });
+});
+
+describe("formatGapMessages", () => {
+  test("returns empty string for no gap messages", () => {
+    expect(formatGapMessages([])).toBe("");
+  });
+
+  test("formats messages with user mentions and header", () => {
+    const gap: ThreadMessage[] = [
+      msg("U1", "Use JWT for auth", "1.0"),
+      msg("U2", "Agreed", "2.0"),
+    ];
+
+    const result = formatGapMessages(gap);
+    expect(result).toContain("[Thread context");
+    expect(result).toContain("<@U1>: Use JWT for auth");
+    expect(result).toContain("<@U2>: Agreed");
+    expect(result).toEndWith("---\n");
+  });
+
+  test("handles missing user with 'unknown'", () => {
+    const gap: ThreadMessage[] = [
+      { ts: "1.0", text: "Hello" },
+    ];
+
+    const result = formatGapMessages(gap);
+    expect(result).toContain("<@unknown>: Hello");
+  });
+
+  test("handles missing text gracefully", () => {
+    const gap: ThreadMessage[] = [
+      { ts: "1.0", user: "U1" },
+    ];
+
+    const result = formatGapMessages(gap);
+    expect(result).toContain("<@U1>: ");
+  });
+});