@desplega.ai/agent-swarm 2.4.4 → 2.5.0

package/src/tests/transcription.test.ts

@@ -0,0 +1,299 @@
+import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, test } from "bun:test";
+import {
+  isTranscriptionConfigured,
+  NOT_TRANSCRIBED_NOTE,
+  resolveTranscriptionConfig,
+  TRANSCRIPTION_ENV_KEYS,
+  TranscriptionError,
+  transcribeAudio,
+  transcribeAudioNotes,
+} from "../utils/transcription";
+
+// Includes the provider keys the fallback reads: a worker shell often has
+// OPENAI_API_KEY or ELEVENLABS_API_KEY set, which would leak into every test.
+const ENV_KEYS = TRANSCRIPTION_ENV_KEYS;
+const savedEnv = new Map(ENV_KEYS.map((key) => [key, process.env[key]]));
+
+type Captured = {
+  path: string;
+  authorization: string | null;
+  xiApiKey: string | null;
+  fields: string[];
+  model: FormDataEntryValue | null;
+  modelId: FormDataEntryValue | null;
+  filename: string;
+};
+
+const captured: Captured[] = [];
+// The file part's Content-Type as sent. Bun's `formData()` re-derives a File's
+// type from its extension (`.webm` reads back as video/webm), so read it raw.
+const sentFileTypes: string[] = [];
+let reply: () => Response = () => Response.json({ text: " hello " });
+let stt: ReturnType<typeof Bun.serve>;
+
+beforeAll(() => {
+  for (const key of ENV_KEYS) delete process.env[key];
+  stt = Bun.serve({
+    port: 0,
+    hostname: "127.0.0.1",
+    async fetch(req) {
+      const raw = await req.clone().text();
+      sentFileTypes.push(
+        /name="file"; filename="[^"]*"\r\nContent-Type: ([^\r\n]+)/.exec(raw)?.[1] ?? "",
+      );
+      const form = await req.formData();
+      captured.push({
+        path: new URL(req.url).pathname,
+        authorization: req.headers.get("authorization"),
+        xiApiKey: req.headers.get("xi-api-key"),
+        fields: [...form.keys()].sort(),
+        model: form.get("model"),
+        modelId: form.get("model_id"),
+        filename: (form.get("file") as File).name,
+      });
+      return reply();
+    },
+  });
+});
+
+afterAll(() => {
+  stt.stop(true);
+  for (const [key, value] of savedEnv) {
+    if (value === undefined) delete process.env[key];
+    else process.env[key] = value;
+  }
+});
+
+afterEach(() => {
+  captured.length = 0;
+  sentFileTypes.length = 0;
+  reply = () => Response.json({ text: " hello " });
+  for (const key of ENV_KEYS) delete process.env[key];
+});
+
+function configure(provider?: string) {
+  process.env.TRANSCRIPTION_API_KEY = "stt-test-key-123456";
+  process.env.TRANSCRIPTION_BASE_URL = `http://127.0.0.1:${stt.port}/v1`;
+  if (provider) process.env.TRANSCRIPTION_PROVIDER = provider;
+}
+
+const audio = {
+  data: new Blob([new Uint8Array([1, 2, 3])]),
+  filename: "note.ogg",
+  mimeType: "audio/ogg",
+};
+
+describe("transcribeAudio request shape", () => {
+  test("elevenlabs posts to /speech-to-text with xi-api-key and model_id", async () => {
+    configure("elevenlabs");
+    expect(await transcribeAudio(audio)).toBe("hello");
+    expect(captured).toEqual([
+      {
+        path: "/v1/speech-to-text",
+        authorization: null,
+        xiApiKey: "stt-test-key-123456",
+        fields: ["file", "model_id"],
+        model: null,
+        modelId: "scribe_v2",
+        filename: "note.ogg",
+      },
+    ]);
+  });
+
+  test("elevenlabs honours TRANSCRIPTION_MODEL in model_id", async () => {
+    configure("ElevenLabs");
+    process.env.TRANSCRIPTION_MODEL = "scribe_v1";
+    await transcribeAudio(audio);
+    expect(captured[0]).toMatchObject({ fields: ["file", "model_id"], modelId: "scribe_v1" });
+  });
+
+  test("negative control: the default provider keeps the OpenAI shape", async () => {
+    configure();
+    expect(await transcribeAudio(audio)).toBe("hello");
+    expect(captured).toEqual([
+      {
+        path: "/v1/audio/transcriptions",
+        authorization: "Bearer stt-test-key-123456",
+        xiApiKey: null,
+        fields: ["file", "model"],
+        model: "whisper-1",
+        modelId: null,
+        filename: "note.ogg",
+      },
+    ]);
+  });
+
+  test("an unknown provider fails before any request", async () => {
+    configure("deepgram");
+    await expect(transcribeAudio(audio)).rejects.toThrow(
+      new TranscriptionError(
+        'TRANSCRIPTION_PROVIDER "deepgram" is not supported (use openai, groq, elevenlabs)',
+      ),
+    );
+    expect(captured).toHaveLength(0);
+  });
+
+  test("an elevenlabs error detail is surfaced with the key scrubbed", async () => {
+    configure("elevenlabs");
+    reply = () =>
+      Response.json(
+        { detail: { status: "invalid_api_key", message: "Invalid key stt-test-key-123456" } },
+        { status: 401 },
+      );
+    await expect(transcribeAudio(audio)).rejects.toThrow(
+      "Invalid key [REDACTED:TRANSCRIPTION_API_KEY]",
+    );
+  });
+});
+
+describe("provider key fallback", () => {
+  // Built at runtime so the secret scanner does not read them as keys.
+  const fake = (provider: string) => [provider, "fixture", "value"].join("-");
+  const ELEVEN_FAKE = fake("eleven");
+  const OPENAI_FAKE = fake("openai");
+  const GROQ_FAKE = fake("groq");
+
+  // Auto-detected keys always go to the provider's public endpoint, so record
+  // that URL and forward the request to the local stub on the same path.
+  const realFetch = globalThis.fetch;
+  const calledUrls: string[] = [];
+  beforeEach(() => {
+    calledUrls.length = 0;
+    globalThis.fetch = (async (input: string | URL | Request, init?: RequestInit) => {
+      const url = new URL(String(input));
+      calledUrls.push(url.href);
+      return realFetch(`http://127.0.0.1:${stt.port}${url.pathname}`, init);
+    }) as typeof fetch;
+  });
+  afterEach(() => {
+    globalThis.fetch = realFetch;
+  });
+
+  test("no key at all means not configured", async () => {
+    expect(resolveTranscriptionConfig()).toBeNull();
+    expect(isTranscriptionConfigured()).toBe(false);
+    const notes = await transcribeAudioNotes([{ key: "a", name: "a.ogg", data: audio.data }], "t");
+    expect(notes.get("a")).toBe(NOT_TRANSCRIBED_NOTE);
+    expect(NOT_TRANSCRIBED_NOTE).toBe(
+      "(not transcribed: no transcription provider configured, set TRANSCRIPTION_API_KEY or one of ELEVENLABS_API_KEY, OPENAI_API_KEY, GROQ_API_KEY)",
+    );
+    expect(calledUrls).toHaveLength(0);
+  });
+
+  test("ELEVENLABS_API_KEY alone uses the elevenlabs shape", async () => {
+    process.env.ELEVENLABS_API_KEY = ELEVEN_FAKE;
+    expect(resolveTranscriptionConfig()).toMatchObject({
+      provider: "elevenlabs",
+      keyEnv: "ELEVENLABS_API_KEY",
+      source: "auto",
+    });
+    expect(await transcribeAudio(audio)).toBe("hello");
+    expect(calledUrls).toEqual(["https://api.elevenlabs.io/v1/speech-to-text"]);
+    expect(captured[0]).toMatchObject({
+      xiApiKey: ELEVEN_FAKE,
+      authorization: null,
+      modelId: "scribe_v2",
+    });
+  });
+
+  test("OPENAI_API_KEY alone uses the openai shape", async () => {
+    process.env.OPENAI_API_KEY = OPENAI_FAKE;
+    expect(resolveTranscriptionConfig()).toMatchObject({ provider: "openai", source: "auto" });
+    await transcribeAudio(audio);
+    expect(calledUrls).toEqual(["https://api.openai.com/v1/audio/transcriptions"]);
+    expect(captured[0]).toMatchObject({
+      authorization: `Bearer ${OPENAI_FAKE}`,
+      model: "whisper-1",
+    });
+  });
+
+  test("GROQ_API_KEY alone uses Groq's OpenAI-compatible endpoint and whisper model", async () => {
+    process.env.GROQ_API_KEY = GROQ_FAKE;
+    expect(resolveTranscriptionConfig()).toMatchObject({
+      provider: "groq",
+      keyEnv: "GROQ_API_KEY",
+    });
+    await transcribeAudio(audio);
+    expect(calledUrls).toEqual(["https://api.groq.com/openai/v1/audio/transcriptions"]);
+    expect(captured[0]).toMatchObject({
+      authorization: `Bearer ${GROQ_FAKE}`,
+      model: "whisper-large-v3-turbo",
+    });
+  });
+
+  test("ElevenLabs wins over OpenAI and Groq when all are set", async () => {
+    process.env.OPENAI_API_KEY = OPENAI_FAKE;
+    process.env.GROQ_API_KEY = GROQ_FAKE;
+    process.env.ELEVENLABS_API_KEY = ELEVEN_FAKE;
+    await transcribeAudio(audio);
+    expect(captured[0]).toMatchObject({ xiApiKey: ELEVEN_FAKE, authorization: null });
+  });
+
+  test("OpenAI wins over Groq", () => {
+    process.env.GROQ_API_KEY = GROQ_FAKE;
+    process.env.OPENAI_API_KEY = OPENAI_FAKE;
+    expect(resolveTranscriptionConfig()?.provider).toBe("openai");
+  });
+
+  test("an explicit TRANSCRIPTION_API_KEY overrides both detected keys", async () => {
+    process.env.OPENAI_API_KEY = OPENAI_FAKE;
+    process.env.ELEVENLABS_API_KEY = ELEVEN_FAKE;
+    configure();
+    expect(resolveTranscriptionConfig()).toMatchObject({
+      provider: "openai",
+      keyEnv: "TRANSCRIPTION_API_KEY",
+      source: "explicit",
+    });
+    await transcribeAudio(audio);
+    // The explicit key honours TRANSCRIPTION_BASE_URL.
+    expect(calledUrls).toEqual([`http://127.0.0.1:${stt.port}/v1/audio/transcriptions`]);
+    expect(captured[0]).toMatchObject({
+      authorization: "Bearer stt-test-key-123456",
+      xiApiKey: null,
+    });
+  });
+
+  test("an auto-detected key never goes to TRANSCRIPTION_BASE_URL", async () => {
+    process.env.ELEVENLABS_API_KEY = ELEVEN_FAKE;
+    process.env.TRANSCRIPTION_BASE_URL = "https://collector.example/v1";
+    await transcribeAudio(audio);
+    expect(calledUrls).toEqual(["https://api.elevenlabs.io/v1/speech-to-text"]);
+  });
+
+  test("a pinned provider uses only its own key", async () => {
+    process.env.ELEVENLABS_API_KEY = ELEVEN_FAKE;
+    process.env.OPENAI_API_KEY = OPENAI_FAKE;
+    process.env.TRANSCRIPTION_PROVIDER = "openai";
+    await transcribeAudio(audio);
+    expect(captured[0]).toMatchObject({ authorization: `Bearer ${OPENAI_FAKE}` });
+
+    delete process.env.OPENAI_API_KEY;
+    expect(isTranscriptionConfigured()).toBe(false);
+  });
+
+  test("a detected key is scrubbed from errors under its own name", async () => {
+    process.env.ELEVENLABS_API_KEY = ELEVEN_FAKE;
+    reply = () => Response.json({ detail: `bad key ${ELEVEN_FAKE}` }, { status: 401 });
+    await expect(transcribeAudio(audio)).rejects.toThrow("bad key [REDACTED:ELEVENLABS_API_KEY]");
+  });
+
+  // The composer's mic button records webm in Chrome and Firefox; the upload
+  // route drops `;codecs=` before it gets here. Each provider reads the format
+  // from the file name, and all three list webm as supported.
+  test.each([
+    ["elevenlabs", "ELEVENLABS_API_KEY", "https://api.elevenlabs.io/v1/speech-to-text"],
+    ["openai", "OPENAI_API_KEY", "https://api.openai.com/v1/audio/transcriptions"],
+    ["groq", "GROQ_API_KEY", "https://api.groq.com/openai/v1/audio/transcriptions"],
+  ])("a recorded webm clip reaches %s as a .webm audio/webm file", async (name, keyEnv, url) => {
+    process.env[keyEnv] = fake(name);
+    const clip = new Blob([new Uint8Array([0x1a, 0x45, 0xdf, 0xa3])], { type: "audio/webm" });
+    const notes = await transcribeAudioNotes(
+      [{ key: "c", name: "recording-2026-10-21-143005.webm", data: clip, mimeType: "audio/webm" }],
+      "t",
+    );
+    expect(notes.get("c")).toBe("[Transcript of recording-2026-10-21-143005.webm]\nhello");
+    expect(calledUrls).toEqual([url]);
+    expect(captured[0]).toMatchObject({ filename: "recording-2026-10-21-143005.webm" });
+    expect(sentFileTypes).toEqual(["audio/webm"]);
+  });
+});

package/src/tests/vcs-bitbucket.test.ts

@@ -0,0 +1,91 @@
+import { describe, expect, test } from "bun:test";
+import { bitbucketFullName, isBitbucketUrl, parseBitbucketRepoUrl } from "../vcs/bitbucket";
+import { detectVcsProvider } from "../vcs/index";
+
+describe("Bitbucket Cloud URL helpers", () => {
+  test("isBitbucketUrl accepts bitbucket.org remotes only", () => {
+    for (const url of [
+      "https://bitbucket.org/ws/repo",
+      "https://BitBucket.org/ws/repo",
+      "https://x-token-auth@bitbucket.org/ws/repo.git",
+      "git@bitbucket.org:ws/repo.git",
+      "ssh://git@bitbucket.org/ws/repo.git",
+    ]) {
+      expect(isBitbucketUrl(url)).toBe(true);
+    }
+    for (const url of [
+      "https://github.com/ws/repo",
+      "https://notbitbucket.org/ws/repo",
+      "https://bitbucket.org.evil.com/ws/repo",
+      "https://example.com/bitbucket.org.html",
+      "https://gitlab.com/bitbucket.org/repo.git",
+      "git@gitlab.com:bitbucket.org/repo.git",
+      "https://github.com/acme/bitbucket.org",
+      "ws/repo",
+    ]) {
+      expect(isBitbucketUrl(url)).toBe(false);
+    }
+  });
+
+  test("parses https remotes with and without user@ and .git", () => {
+    const expected = { workspace: "my-ws", repoSlug: "my-repo" };
+    for (const url of [
+      "https://bitbucket.org/my-ws/my-repo",
+      "https://bitbucket.org/my-ws/my-repo/",
+      "https://bitbucket.org/my-ws/my-repo.git",
+      "https://alice@bitbucket.org/my-ws/my-repo.git",
+      "https://x-token-auth:tok@bitbucket.org/my-ws/my-repo.git",
+      "  https://bitbucket.org/my-ws/my-repo.git  ",
+      "https://bitbucket.org/my-ws/my-repo/pull-requests/7",
+    ]) {
+      expect(parseBitbucketRepoUrl(url)).toEqual(expected);
+    }
+  });
+
+  test("parses ssh remotes", () => {
+    expect(parseBitbucketRepoUrl("git@bitbucket.org:my-ws/my-repo.git")).toEqual({
+      workspace: "my-ws",
+      repoSlug: "my-repo",
+    });
+    expect(parseBitbucketRepoUrl("git@bitbucket.org:my-ws/my-repo")).toEqual({
+      workspace: "my-ws",
+      repoSlug: "my-repo",
+    });
+    expect(parseBitbucketRepoUrl("ssh://git@bitbucket.org/my-ws/my-repo.git")).toEqual({
+      workspace: "my-ws",
+      repoSlug: "my-repo",
+    });
+  });
+
+  test("keeps dots inside repository slugs", () => {
+    expect(parseBitbucketRepoUrl("https://bitbucket.org/ws/my.site.git")).toEqual({
+      workspace: "ws",
+      repoSlug: "my.site",
+    });
+    expect(bitbucketFullName("git@bitbucket.org:ws/my.site.git")).toBe("ws/my.site");
+  });
+
+  test("returns null for non-Bitbucket or incomplete URLs", () => {
+    expect(parseBitbucketRepoUrl("https://github.com/ws/repo")).toBeNull();
+    expect(parseBitbucketRepoUrl("https://bitbucket.org/ws")).toBeNull();
+    expect(parseBitbucketRepoUrl("https://bitbucket.org/")).toBeNull();
+    expect(parseBitbucketRepoUrl("git@bitbucket.org:ws.git")).toBeNull();
+    expect(parseBitbucketRepoUrl("not a url bitbucket.org")).toBeNull();
+    expect(bitbucketFullName("https://gitlab.com/group/project")).toBeNull();
+  });
+
+  test("bitbucketFullName yields workspace/repo_slug", () => {
+    expect(bitbucketFullName("https://bitbucket.org/ws/repo.git")).toBe("ws/repo");
+    expect(bitbucketFullName("git@bitbucket.org:ws/repo.git")).toBe("ws/repo");
+  });
+
+  test("detectVcsProvider checks Bitbucket before the GitHub owner/repo fallback", () => {
+    expect(detectVcsProvider("https://bitbucket.org/ws/repo")).toBe("bitbucket");
+    expect(detectVcsProvider("ws/repo")).toBe("github");
+  });
+
+  test("a bitbucket.org path segment on another host keeps that host's provider", () => {
+    expect(detectVcsProvider("https://gitlab.com/bitbucket.org/repo.git")).toBe("gitlab");
+    expect(parseBitbucketRepoUrl("https://gitlab.com/bitbucket.org/repo.git")).toBeNull();
+  });
+});

package/src/tests/vcs-provider-isolation.test.ts

@@ -0,0 +1,123 @@
+import { afterAll, beforeAll, expect, test } from "bun:test";
+import { unlink } from "node:fs/promises";
+import {
+  closeDb,
+  createAgent,
+  createTaskExtended,
+  findTaskByVcs,
+  getTaskById,
+  initDb,
+} from "../be/db";
+import { handlePullRequestCreated, resetBitbucketDedup } from "../bitbucket/handlers";
+import { handlePullRequest } from "../github/handlers";
+import { GITHUB_BOT_NAME } from "../github/mentions";
+import type { PullRequestEvent } from "../github/types";
+import { handleMergeRequest } from "../gitlab/handlers";
+import type { MergeRequestEvent } from "../gitlab/types";
+import mentionSample from "./fixtures/bitbucket/pullrequest-created-mention.json";
+
+// The same `owner/repo` + number can exist on GitHub, GitLab and Bitbucket at
+// once. Each host's webhook must act only on its own tasks.
+const DB = "./test-vcs-provider-isolation.sqlite";
+beforeAll(async () => {
+  initDb(DB);
+  await createAgent({
+    id: crypto.randomUUID(),
+    name: "Provider isolation lead",
+    status: "idle",
+    isLead: true,
+  });
+  process.env.BITBUCKET_BOT_ACCOUNT_ID = "557058:00000000-0000-4000-8000-0000000000b0";
+});
+afterAll(async () => {
+  closeDb();
+  delete process.env.BITBUCKET_BOT_ACCOUNT_ID;
+  resetBitbucketDedup();
+  for (const suffix of ["", "-wal", "-shm"]) await unlink(DB + suffix).catch(() => {});
+});
+
+async function createBitbucketTask(id: number) {
+  const event = structuredClone(mentionSample);
+  event.pullrequest.id = id;
+  const result = await handlePullRequestCreated(event);
+  expect(result.created).toBe(true);
+  return (await getTaskById(result.taskId!))!;
+}
+
+function gitlabMerge(iid: number): MergeRequestEvent {
+  return {
+    object_kind: "merge_request",
+    event_type: "merge_request",
+    user: { id: 1, name: "Test user", username: "review2339", avatar_url: "" },
+    project: {
+      id: 1,
+      name: "widgets",
+      path_with_namespace: "acme-ws/widgets",
+      web_url: "https://gitlab.com/acme-ws/widgets",
+      default_branch: "main",
+    },
+    object_attributes: {
+      id: 101,
+      iid,
+      title: "Unrelated GitLab MR",
+      description: "",
+      state: "merged",
+      action: "merge",
+      source_branch: "feature",
+      target_branch: "main",
+      url: `https://gitlab.com/acme-ws/widgets/-/merge_requests/${iid}`,
+      last_commit: null,
+      author_id: 1,
+    },
+  };
+}
+
+function githubEvent(number: number, action: string): PullRequestEvent {
+  return {
+    action,
+    pull_request: {
+      number,
+      title: "Unrelated GitHub PR",
+      body: "Please review",
+      html_url: `https://github.com/acme-ws/widgets/pull/${number}`,
+      user: { login: "review2339" },
+      head: { ref: "feature", sha: "abc123" },
+      base: { ref: "main" },
+      merged: false,
+    },
+    repository: { full_name: "acme-ws/widgets", html_url: "https://github.com/acme-ws/widgets" },
+    sender: { login: "review2339" },
+    assignee: { login: GITHUB_BOT_NAME, id: 2 },
+    requested_reviewer: { login: GITHUB_BOT_NAME, id: 2 },
+  };
+}
+
+test("GitLab merge must not cancel a real Bitbucket task", async () => {
+  const task = await createBitbucketTask(701);
+  await handleMergeRequest(gitlabMerge(701));
+  expect((await getTaskById(task.id))?.status).toBe(task.status);
+});
+
+test("GitHub unassignment must not cancel a real Bitbucket task", async () => {
+  const task = await createBitbucketTask(702);
+  await handlePullRequest(githubEvent(702, "unassigned"));
+  expect((await getTaskById(task.id))?.status).toBe(task.status);
+});
+
+test("Bitbucket task must not suppress an unrelated GitHub review request", async () => {
+  await createBitbucketTask(703);
+  const result = await handlePullRequest(githubEvent(703, "review_requested"));
+  expect(result.created).toBe(true);
+});
+
+test("GitHub lookup still matches a legacy task with no vcsProvider", async () => {
+  const legacy = await createTaskExtended("Legacy GitHub PR task", {
+    source: "github",
+    vcsRepo: "acme-ws/legacy",
+    vcsNumber: 704,
+  });
+  expect(legacy.vcsProvider).toBeUndefined();
+  expect((await findTaskByVcs("acme-ws/legacy", 704, "github"))?.id).toBe(legacy.id);
+  expect(await findTaskByVcs("acme-ws/legacy", 704, "bitbucket")).toBeNull();
+  expect(await findTaskByVcs("acme-ws/legacy", 704, "gitlab")).toBeNull();
+});

package/src/tests/vcs-provider.test.ts

@@ -20,8 +20,23 @@ describe("detectVcsProvider", () => {
     expect(detectVcsProvider("https://gitlab.internal/group/project")).toBe("gitlab");
   });
 
+  test("detects bitbucket.org URLs in https, ssh and .git forms", () => {
+    for (const url of [
+      "https://bitbucket.org/org/repo",
+      "https://bitbucket.org/org/repo.git",
+      "https://user@bitbucket.org/org/repo.git",
+      "git@bitbucket.org:org/repo.git",
+      "ssh://git@bitbucket.org/org/repo.git",
+      // A slug containing "github" or "gitlab" must not fall through to those hosts.
+      "https://bitbucket.org/org/github-mirror",
+      "git@bitbucket.org:gitlab-team/repo.git",
+    ]) {
+      expect(detectVcsProvider(url)).toBe("bitbucket");
+    }
+  });
+
   test("returns null for unrecognised URLs", () => {
-    expect(detectVcsProvider("https://bitbucket.org/org/repo")).toBeNull();
     expect(detectVcsProvider("https://example.com")).toBeNull();
+    expect(detectVcsProvider("https://notbitbucket.org/org/repo")).toBeNull();
   });
 });

package/src/tests/vcs-tracking.test.ts

@@ -122,7 +122,7 @@ describe("updateTaskVcs", () => {
     });
 
     // Before update — no VCS fields, shouldn't be found
-    const notFound = await findTaskByVcs("owner/findme", 99);
+    const notFound = await findTaskByVcs("owner/findme", 99, "github");
     expect(notFound).toBeNull();
 
     await updateTaskVcs(task.id, {
@@ -133,7 +133,7 @@ describe("updateTaskVcs", () => {
     });
 
     // After update — should be found (task is pending, not completed/failed)
-    const found = await findTaskByVcs("owner/findme", 99);
+    const found = await findTaskByVcs("owner/findme", 99, "github");
     expect(found).not.toBeNull();
     expect(found!.id).toBe(task.id);
   });
@@ -171,7 +171,7 @@ describe("updateTaskVcs", () => {
       await startTask(task.id);
       await c.terminate(task.id);
 
-      const found = await findTaskByVcs("owner/terminal", c.number);
+      const found = await findTaskByVcs("owner/terminal", c.number, "github");
       expect(found).toBeNull();
     }
   });