@desplega.ai/agent-swarm 1.111.0 → 1.112.0

package/src/tests/github-handlers-inline-comments.test.ts

@@ -4,13 +4,17 @@
  * Covers:
  * - CHANGES_REQUESTED review with inline comments → task description includes them
  * - commented-no-body-with-inline-comments → task is created (not skipped)
- * - commented-no-body-no-inline-comments → task is skipped (existing behavior preserved)
- * - commented-no-body-no-installation → graceful fallback, task is skipped
+ * - commented-no-body-no-inline-comments with trusted fetch → task is skipped
+ * - degraded fetch/no installation → task is created with a loud manual-fetch block
  */
 import { afterAll, beforeAll, beforeEach, describe, expect, mock, spyOn, test } from "bun:test";
 import { unlink } from "node:fs/promises";
 import { closeDb, createAgent, getDb, initDb } from "../be/db";
-import { handleComment, handlePullRequestReview } from "../github/handlers";
+import {
+  handleComment,
+  handlePullRequestReview,
+  setReviewCommentsRetryDelayForTests,
+} from "../github/handlers";
 import { GITHUB_BOT_NAME } from "../github/mentions";
 import type { CommentEvent, PullRequestReviewEvent } from "../github/types";
 import { getTemplateDefinition } from "../prompts/registry";
@@ -55,6 +59,7 @@ beforeAll(async () => {
 });
 
 afterAll(async () => {
+  setReviewCommentsRetryDelayForTests();
   closeDb();
   await unlink(TEST_DB_PATH).catch(() => {});
   await unlink(`${TEST_DB_PATH}-wal`).catch(() => {});
@@ -63,6 +68,7 @@ afterAll(async () => {
 
 beforeEach(async () => {
   await ensureTemplatesRegistered();
+  setReviewCommentsRetryDelayForTests(() => {});
   getDb().prepare("DELETE FROM agent_tasks").run();
 });
 
@@ -72,6 +78,16 @@ const BASE_REPO = { full_name: "test/repo", html_url: "https://github.com/test/r
 
 let reviewIdCounter = 9000;
 
+type TestInlineComment = {
+  id: number;
+  path: string;
+  line: number | null;
+  body: string;
+  html_url: string;
+  diff_hunk: string;
+  pull_request_review_id?: number | null;
+};
+
 function makeReviewEvent(opts: {
   state: "changes_requested" | "commented";
   body: string | null;
@@ -104,7 +120,7 @@ function makeReviewEvent(opts: {
   };
 }
 
-const SAMPLE_INLINE_COMMENTS = [
+const SAMPLE_INLINE_COMMENTS: TestInlineComment[] = [
   {
     id: 1001,
     path: "src/domain_tables.go",
@@ -123,16 +139,16 @@ const SAMPLE_INLINE_COMMENTS = [
   },
 ];
 
-function mockFetchWithComments(
-  comments: typeof SAMPLE_INLINE_COMMENTS | [],
-): ReturnType<typeof spyOn> {
-  return spyOn(globalThis, "fetch").mockImplementationOnce(
-    async () =>
-      new Response(JSON.stringify(comments), {
-        status: 200,
-        headers: { "Content-Type": "application/json" },
-      }),
-  );
+function commentsResponse(comments: TestInlineComment[]): Response {
+  return new Response(JSON.stringify(comments), {
+    status: 200,
+    headers: { "Content-Type": "application/json" },
+  });
+}
+
+function mockFetchWithComments(comments: TestInlineComment[]): ReturnType<typeof spyOn> {
+  const fetchSpy = spyOn(globalThis, "fetch").mockImplementation(async () => commentsResponse([]));
+  return fetchSpy.mockImplementationOnce(async () => commentsResponse(comments));
 }
 
 function getLastTaskText(): string | undefined {
@@ -142,10 +158,19 @@ function getLastTaskText(): string | undefined {
   return row?.task;
 }
 
+function expectDegradedBlock(text: string | undefined): void {
+  expect(text).toContain("## ⚠️ Inline comments could NOT be auto-fetched");
+  expect(text).toContain(
+    "gh api \"repos/test/repo/pulls/99/comments?per_page=100\" --jq '.[] | {id,path,line,body}'",
+  );
+  expect(text).toContain("Do NOT dispatch off the review body alone");
+  expect(text).toContain("Address EVERY inline comment");
+}
+
 // ── Tests ──
 
 describe("inline review comment surfacing", () => {
-  test("CHANGES_REQUESTED review with inline comments: task includes path:line and bodies", async () => {
+  test("happy path: CHANGES_REQUESTED review with inline comments includes path:line and bodies", async () => {
     const fetchSpy = mockFetchWithComments(SAMPLE_INLINE_COMMENTS);
 
     const event = makeReviewEvent({
@@ -166,6 +191,29 @@ describe("inline review comment surfacing", () => {
     expect(text).toContain("Why is this hardcoded?");
     expect(text).toContain("Inline review comments");
     expect(text).toContain("reply to and resolve each inline review thread");
+    expect(text).not.toContain("Inline comments could NOT be auto-fetched");
+  });
+
+  test("consistency lag: empty review-scoped fetch retries and embeds later comments", async () => {
+    const fetchSpy = spyOn(globalThis, "fetch")
+      .mockImplementation(async () => commentsResponse([]))
+      .mockImplementationOnce(async () => commentsResponse([]))
+      .mockImplementationOnce(async () => commentsResponse([SAMPLE_INLINE_COMMENTS[0]]));
+
+    const event = makeReviewEvent({
+      state: "changes_requested",
+      body: "Please handle the line note",
+      installationId: 123,
+    });
+    const result = await handlePullRequestReview(event);
+
+    expect(result.created).toBe(true);
+    fetchSpy.mockRestore();
+
+    const text = getLastTaskText();
+    expect(text).toContain("src/domain_tables.go:77");
+    expect(text).toContain("This logic looks wrong");
+    expect(text).not.toContain("Inline comments could NOT be auto-fetched");
   });
 
   test("commented review with no body but with inline comments: task is created, not skipped", async () => {
@@ -180,26 +228,36 @@ describe("inline review comment surfacing", () => {
   });
 
   test("commented review with no body and no inline comments: task is skipped", async () => {
-    const fetchSpy = mockFetchWithComments([]);
+    const fetchSpy = spyOn(globalThis, "fetch")
+      .mockImplementation(async () => commentsResponse([]))
+      .mockImplementationOnce(async () => commentsResponse([]))
+      .mockImplementationOnce(async () => commentsResponse([]))
+      .mockImplementationOnce(async () => commentsResponse([]))
+      .mockImplementationOnce(async () => commentsResponse([]))
+      .mockImplementationOnce(async () => commentsResponse([]));
 
     const event = makeReviewEvent({ state: "commented", body: null, installationId: 123 });
     const result = await handlePullRequestReview(event);
 
+    expect(fetchSpy).toHaveBeenCalledTimes(5);
     fetchSpy.mockRestore();
 
     expect(result.created).toBe(false);
   });
 
-  test("commented review with no body and no installation: graceful fallback, task is skipped", async () => {
+  test("commented review with no body and no installation: degraded task is created", async () => {
     const event = makeReviewEvent({ state: "commented", body: null });
     const result = await handlePullRequestReview(event);
-    expect(result.created).toBe(false);
+
+    expect(result.created).toBe(true);
+    expectDegradedBlock(getLastTaskText());
   });
 
-  test("review comments fetch failure: task still created (graceful degradation)", async () => {
-    const fetchSpy = spyOn(globalThis, "fetch").mockImplementationOnce(
-      async () => new Response("Internal Server Error", { status: 500 }),
-    );
+  test("non-2xx review-scoped fetch: degraded block is present", async () => {
+    const fetchSpy = spyOn(globalThis, "fetch")
+      .mockImplementation(async () => commentsResponse([]))
+      .mockImplementationOnce(async () => new Response("Internal Server Error", { status: 500 }))
+      .mockImplementationOnce(async () => commentsResponse([]));
 
     const event = makeReviewEvent({
       state: "changes_requested",
@@ -214,8 +272,39 @@ describe("inline review comment surfacing", () => {
     expect(result.created).toBe(true);
     const text = getLastTaskText();
     expect(text).toContain("Needs work");
-    // No inline comments section when fetch failed
-    expect(text).not.toContain("Inline review comments");
+    expectDegradedBlock(text);
+    expect(text).not.toContain("Inline review comments (");
+  });
+
+  test("PR-level fallback embeds a review comment missed by review-scoped fetch", async () => {
+    const event = makeReviewEvent({
+      state: "changes_requested",
+      body: "Review-scoped path missed this",
+      installationId: 123,
+    });
+    const fallbackComment = {
+      ...SAMPLE_INLINE_COMMENTS[1],
+      pull_request_review_id: event.review.id,
+    };
+    const fetchSpy = spyOn(globalThis, "fetch")
+      .mockImplementation(async () => commentsResponse([]))
+      .mockImplementationOnce(async () => commentsResponse([]))
+      .mockImplementationOnce(async () => commentsResponse([]))
+      .mockImplementationOnce(async () => commentsResponse([]))
+      .mockImplementationOnce(async () => commentsResponse([]))
+      .mockImplementationOnce(async () => commentsResponse([fallbackComment]));
+
+    const result = await handlePullRequestReview(event);
+
+    fetchSpy.mockRestore();
+
+    expect(result.created).toBe(true);
+    const text = getLastTaskText();
+    expect(text).toContain("config/table-renderers.json:7");
+    expect(text).toContain("Why is this hardcoded?");
+    expect(text).toContain("Inline review comments (1)");
+    expect(text).toContain("Address EVERY inline comment");
+    expect(text).not.toContain("Inline comments could NOT be auto-fetched");
   });
 
   test("pagination: two-page review comment response surfaces all comments from both pages", async () => {
@@ -225,6 +314,7 @@ describe("inline review comment surfacing", () => {
       "https://api.github.com/repos/test/repo/pulls/99/reviews/9001/comments?per_page=100&page=2";
 
     const fetchSpy = spyOn(globalThis, "fetch")
+      .mockImplementation(async () => commentsResponse([]))
       .mockImplementationOnce(
         async () =>
           new Response(JSON.stringify(page1), {

package/src/tests/runner-repo-autostash.test.ts

@@ -4,7 +4,7 @@ import { mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { promisify } from "node:util";
-import { ensureRepoForTask } from "../commands/runner";
+import { ensureRepoForTask, isFirstKickoffTask } from "../commands/runner";
 
 const execFileAsync = promisify(execFile);
 
@@ -145,4 +145,171 @@ describe("ensureRepoForTask auto-stash refresh", () => {
     expect(await readFile(join(clonePath, "remote.txt"), "utf8")).toBe("remote commit\n");
     expect((await git(clonePath, ["status", "--porcelain"])).trim()).toBe("");
   });
+
+  test("first kickoff hard-resets a leftover feature branch back to origin/default", async () => {
+    const remotePath = join(tempRoot, "remote.git");
+    const upstreamPath = join(tempRoot, "upstream");
+    const clonePath = join(tempRoot, "clone");
+
+    await gitRaw(["init", "--bare", remotePath]);
+    await mkdir(upstreamPath);
+    await git(upstreamPath, ["init", "-b", "main"]);
+    await configureIdentity(upstreamPath);
+    await writeFile(join(upstreamPath, "README.md"), "initial\n");
+    await commitAll(upstreamPath, "initial commit");
+    await git(upstreamPath, ["remote", "add", "origin", remotePath]);
+    await git(upstreamPath, ["push", "-u", "origin", "main"]);
+
+    await gitRaw(["clone", "--branch", "main", remotePath, clonePath]);
+    await configureIdentity(clonePath);
+
+    // Simulate a prior task leaving a diverged feature branch checked out —
+    // this is the scenario that used to abort the merge and strand the repo.
+    await git(clonePath, ["checkout", "-b", "leftover-feature"]);
+    await writeFile(join(clonePath, "feature.txt"), "leftover work\n");
+    await commitAll(clonePath, "leftover feature commit");
+
+    await writeFile(join(upstreamPath, "remote.txt"), "remote commit\n");
+    await commitAll(upstreamPath, "remote commit");
+    await git(upstreamPath, ["push", "origin", "main"]);
+
+    const result = await withCleanGitEnv(() =>
+      ensureRepoForTask(
+        { url: remotePath, name: "repo", clonePath, defaultBranch: "main" },
+        "test",
+        true,
+      ),
+    );
+
+    expect(result.warning).toBeNull();
+    expect((await git(clonePath, ["rev-parse", "--abbrev-ref", "HEAD"])).trim()).toBe("main");
+    expect((await git(clonePath, ["rev-parse", "HEAD"])).trim()).toBe(
+      (await git(upstreamPath, ["rev-parse", "HEAD"])).trim(),
+    );
+    expect(await readFile(join(clonePath, "remote.txt"), "utf8")).toBe("remote commit\n");
+    expect((await git(clonePath, ["status", "--porcelain"])).trim()).toBe("");
+  });
+
+  test("resume/continuation (isFirstKickoff=false) leaves a leftover feature branch checked out", async () => {
+    const remotePath = join(tempRoot, "remote.git");
+    const upstreamPath = join(tempRoot, "upstream");
+    const clonePath = join(tempRoot, "clone");
+
+    await gitRaw(["init", "--bare", remotePath]);
+    await mkdir(upstreamPath);
+    await git(upstreamPath, ["init", "-b", "main"]);
+    await configureIdentity(upstreamPath);
+    await writeFile(join(upstreamPath, "README.md"), "initial\n");
+    await commitAll(upstreamPath, "initial commit");
+    await git(upstreamPath, ["remote", "add", "origin", remotePath]);
+    await git(upstreamPath, ["push", "-u", "origin", "main"]);
+
+    await gitRaw(["clone", "--branch", "main", remotePath, clonePath]);
+    await configureIdentity(clonePath);
+
+    await git(clonePath, ["checkout", "-b", "in-progress-feature"]);
+    await writeFile(join(clonePath, "feature.txt"), "in-progress work\n");
+    await commitAll(clonePath, "in-progress feature commit");
+
+    const result = await withCleanGitEnv(() =>
+      ensureRepoForTask(
+        { url: remotePath, name: "repo", clonePath, defaultBranch: "main" },
+        "test",
+        false,
+      ),
+    );
+
+    expect(result.warning).toBeNull();
+    expect((await git(clonePath, ["rev-parse", "--abbrev-ref", "HEAD"])).trim()).toBe(
+      "in-progress-feature",
+    );
+    expect(await readFile(join(clonePath, "feature.txt"), "utf8")).toBe("in-progress work\n");
+  });
+});
+
+describe("isFirstKickoffTask", () => {
+  test("a feature task with a parentTaskId but an inactive/unknown parent is still a first kickoff", async () => {
+    expect(
+      await isFirstKickoffTask({ parentTaskId: "parent-1", taskType: "feature" }, async () => null),
+    ).toBe(true);
+  });
+
+  test("a pr-fix task with a parentTaskId but an inactive/unknown parent is still a first kickoff", async () => {
+    expect(
+      await isFirstKickoffTask({ parentTaskId: "parent-1", taskType: "pr-fix" }, async () => null),
+    ).toBe(true);
+  });
+
+  test("a parentTaskId with no status-checker at all is still a first kickoff (taskType alone decides)", async () => {
+    expect(await isFirstKickoffTask({ parentTaskId: "parent-1", taskType: "feature" })).toBe(true);
+  });
+
+  test("an explicit resume task is never a first kickoff", async () => {
+    expect(await isFirstKickoffTask({ taskType: "resume" })).toBe(false);
+  });
+
+  test("a brand-new top-level task with no fields at all is a first kickoff", async () => {
+    expect(await isFirstKickoffTask({})).toBe(true);
+  });
+
+  test("undefined/null task is a first kickoff (safe default)", async () => {
+    expect(await isFirstKickoffTask(undefined)).toBe(true);
+    expect(await isFirstKickoffTask(null)).toBe(true);
+  });
+
+  test("known continuation task types are never a first kickoff, regardless of parent status", async () => {
+    const continuationTypes = [
+      "follow-up",
+      "reroute-decision",
+      "agentmail-reply",
+      "github-comment",
+      "github-review",
+      "gitlab-comment",
+      "gitlab-ci",
+    ];
+    for (const taskType of continuationTypes) {
+      expect(
+        await isFirstKickoffTask({ parentTaskId: "parent-1", taskType }, async () => null),
+      ).toBe(false);
+    }
+  });
+
+  test("a genuinely new root task type (e.g. agentmail-message, no reserved taskType) stays a first kickoff", async () => {
+    expect(await isFirstKickoffTask({ taskType: "agentmail-message" }, async () => null)).toBe(
+      true,
+    );
+  });
+
+  // Regression: a parent-linked NON-resume follow-up (Slack follow-ups and
+  // sibling-awareness both wire parentTaskId with no reserved taskType at
+  // all) must NOT take the hard-reset path when the parent it's continuing
+  // is still active — e.g. an in-progress sibling on the same worker with
+  // maxTasks > 1, or a paused task that may resume onto the same clone.
+  test("a Slack-style follow-up (no distinguishing taskType) with an in-progress parent is NOT a first kickoff", async () => {
+    const fetchParentTaskStatus = async (parentTaskId: string) => {
+      expect(parentTaskId).toBe("active-parent-1");
+      return "in_progress";
+    };
+    expect(
+      await isFirstKickoffTask({ parentTaskId: "active-parent-1" }, fetchParentTaskStatus),
+    ).toBe(false);
+  });
+
+  test("a sibling-awareness-linked task with a paused parent is NOT a first kickoff", async () => {
+    expect(
+      await isFirstKickoffTask(
+        { parentTaskId: "paused-parent-1", taskType: "github-pr" },
+        async () => "paused",
+      ),
+    ).toBe(false);
+  });
+
+  test("a parent-linked task whose parent already completed IS a first kickoff", async () => {
+    expect(
+      await isFirstKickoffTask(
+        { parentTaskId: "done-parent-1", taskType: "feature" },
+        async () => "completed",
+      ),
+    ).toBe(true);
+  });
 });

package/src/tests/slack-delete.test.ts

@@ -0,0 +1,157 @@
+import { afterAll, beforeAll, beforeEach, describe, expect, mock, test } from "bun:test";
+import { unlink } from "node:fs/promises";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { closeDb, createAgent, initDb } from "../be/db";
+import { registerSlackDeleteTool } from "../tools/slack-delete";
+
+const TEST_DB_PATH = "./test-slack-delete.sqlite";
+
+const mockChatDelete = mock(() => Promise.resolve({ ok: true }));
+const mockGetSlackApp = mock(() => ({ client: { chat: { delete: mockChatDelete } } }));
+
+mock.module("../slack/app", () => ({
+  getSlackApp: mockGetSlackApp,
+}));
+
+type RegisteredTool = {
+  handler: (
+    args: unknown,
+    extra: unknown,
+  ) => Promise<{
+    structuredContent: { success: boolean; message: string };
+  }>;
+};
+
+function buildTool() {
+  const server = new McpServer({ name: "slack-delete-test", version: "1.0.0" });
+  registerSlackDeleteTool(server);
+  const registered = (server as unknown as { _registeredTools: Record<string, RegisteredTool> })
+    ._registeredTools;
+  const tool = registered["slack-delete"];
+  if (!tool) throw new Error("slack-delete tool not registered");
+  return tool;
+}
+
+function meta(agentId?: string) {
+  return { sessionId: "s1", requestInfo: { headers: agentId ? { "x-agent-id": agentId } : {} } };
+}
+
+describe("slack-delete", () => {
+  let leadAgentId: string;
+  let nonLeadAgentId: string;
+
+  beforeAll(async () => {
+    for (const suffix of ["", "-wal", "-shm"]) {
+      try {
+        await unlink(`${TEST_DB_PATH}${suffix}`);
+      } catch {}
+    }
+    initDb(TEST_DB_PATH);
+    leadAgentId = createAgent({ name: "Lead", isLead: true, status: "idle" }).id;
+    nonLeadAgentId = createAgent({ name: "Worker", isLead: false, status: "idle" }).id;
+  });
+
+  beforeEach(() => {
+    mockChatDelete.mockClear();
+    mockGetSlackApp.mockClear();
+  });
+
+  afterAll(async () => {
+    closeDb();
+    for (const suffix of ["", "-wal", "-shm"]) {
+      try {
+        await unlink(`${TEST_DB_PATH}${suffix}`);
+      } catch {}
+    }
+  });
+
+  test("rejects when agentId header is missing, without touching Slack", async () => {
+    const tool = buildTool();
+    const result = await tool.handler({ channelId: "C1", messageTs: "1783411554.596189" }, meta());
+
+    expect(result.structuredContent.success).toBe(false);
+    expect(result.structuredContent.message).toBe("Agent ID not found.");
+    expect(mockGetSlackApp).not.toHaveBeenCalled();
+    expect(mockChatDelete).not.toHaveBeenCalled();
+  });
+
+  test("rejects when the agent does not exist, without touching Slack", async () => {
+    const tool = buildTool();
+    const result = await tool.handler(
+      { channelId: "C1", messageTs: "1783411554.596189" },
+      meta("00000000-0000-0000-0000-000000000000"),
+    );
+
+    expect(result.structuredContent.success).toBe(false);
+    expect(result.structuredContent.message).toBe("Agent not found.");
+    expect(mockGetSlackApp).not.toHaveBeenCalled();
+    expect(mockChatDelete).not.toHaveBeenCalled();
+  });
+
+  test("rejects non-lead agents without touching Slack", async () => {
+    const tool = buildTool();
+    const result = await tool.handler(
+      { channelId: "C1", messageTs: "1783411554.596189" },
+      meta(nonLeadAgentId),
+    );
+
+    expect(result.structuredContent.success).toBe(false);
+    expect(result.structuredContent.message).toBe(
+      "Deleting Slack messages requires lead privileges.",
+    );
+    expect(mockGetSlackApp).not.toHaveBeenCalled();
+    expect(mockChatDelete).not.toHaveBeenCalled();
+  });
+
+  test("lead caller deletes using the normalized timestamp", async () => {
+    const tool = buildTool();
+    // 'p' deep-link form must be normalized to the dotted API form before chat.delete.
+    const result = await tool.handler(
+      { channelId: "C1", messageTs: "p1783411554596189" },
+      meta(leadAgentId),
+    );
+
+    expect(result.structuredContent.success).toBe(true);
+    expect(mockChatDelete).toHaveBeenCalledTimes(1);
+    expect(mockChatDelete.mock.calls[0][0]).toEqual({
+      channel: "C1",
+      ts: "1783411554.596189",
+    });
+  });
+
+  test.each([
+    ["message_not_found", "No message found at that timestamp in this channel."],
+    [
+      "cant_delete_message",
+      "Cannot delete this message — the bot can only delete messages it authored.",
+    ],
+    ["channel_not_found", "Channel not found or the bot has no access."],
+    ["not_in_channel", "The bot is not in that channel."],
+  ])("maps Slack error %s to a structured failure message", async (errorCode, expectedMessage) => {
+    mockChatDelete.mockImplementationOnce(() =>
+      Promise.reject(Object.assign(new Error("slack error"), { data: { error: errorCode } })),
+    );
+
+    const tool = buildTool();
+    const result = await tool.handler(
+      { channelId: "C1", messageTs: "1783411554.596189" },
+      meta(leadAgentId),
+    );
+
+    expect(result.structuredContent.success).toBe(false);
+    expect(result.structuredContent.message).toBe(expectedMessage);
+  });
+
+  test("falls back to the raw error message for unmapped Slack error codes", async () => {
+    mockChatDelete.mockImplementationOnce(() => Promise.reject(new Error("boom")));
+
+    const tool = buildTool();
+    const result = await tool.handler(
+      { channelId: "C1", messageTs: "1783411554.596189" },
+      meta(leadAgentId),
+    );
+
+    expect(result.structuredContent.success).toBe(false);
+    expect(result.structuredContent.message).toBe("Failed to delete message: boom");
+  });
+});

package/src/tests/slack-message-text.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, test } from "bun:test";
-import { extractSlackMessageText } from "../slack/message-text";
+import { extractSlackMessageText, parseSlackTs } from "../slack/message-text";
 
 describe("extractSlackMessageText", () => {
   test("returns top-level text when present", () => {
@@ -454,3 +454,39 @@ describe("extractSlackMessageText", () => {
     });
   });
 });
+
+describe("parseSlackTs", () => {
+  test("passes the dotted API form through unchanged", () => {
+    expect(parseSlackTs("1783411554.596189")).toBe("1783411554.596189");
+  });
+
+  test("converts the 'p' deep-link form back to dotted", () => {
+    expect(parseSlackTs("p1783411554596189")).toBe("1783411554.596189");
+  });
+
+  test("converts a bare digit run back to dotted", () => {
+    expect(parseSlackTs("1783411554596189")).toBe("1783411554.596189");
+  });
+
+  test("extracts the ts from a full permalink URL", () => {
+    expect(parseSlackTs("https://example.slack.com/archives/C0123456789/p1783411554596189")).toBe(
+      "1783411554.596189",
+    );
+  });
+
+  test("extracts the ts from a permalink URL with a thread_ts query param", () => {
+    expect(
+      parseSlackTs(
+        "https://example.slack.com/archives/C0123456789/p1783411554596189?thread_ts=1783411000.000100&cid=C0123456789",
+      ),
+    ).toBe("1783411554.596189");
+  });
+
+  test("trims surrounding whitespace before parsing", () => {
+    expect(parseSlackTs("  1783411554.596189  ")).toBe("1783411554.596189");
+  });
+
+  test("falls through unchanged for unrecognized input", () => {
+    expect(parseSlackTs("not-a-ts")).toBe("not-a-ts");
+  });
+});