@vellumai/assistant 0.11.8 → 0.11.9-staging.1

package/src/__tests__/delete-propagation.test.ts

@@ -16,10 +16,23 @@ mock.module("../config/env.js", () => ({
   getGatewayInternalBaseUrl: () => "http://127.0.0.1:7830",
 }));
 
+// A client showing the conversation learns of the deletion through the
+// messages-changed invalidation; capture it rather than opening the SSE hub.
+const publishedConversationIds: string[] = [];
+const actualSyncEvents =
+  await import("../runtime/sync/resource-sync-events.js");
+mock.module("../runtime/sync/resource-sync-events.js", () => ({
+  ...actualSyncEvents,
+  publishConversationMessagesChanged: (conversationId: string) => {
+    publishedConversationIds.push(conversationId);
+  },
+}));
+
 import { eq } from "drizzle-orm";
 
 import {
   readSlackMetadata,
+  readSlackMetadataFromMessageMetadata,
   writeSlackMetadata,
 } from "../messaging/providers/slack/message-metadata.js";
 import { getDb } from "../persistence/db-connection.js";
@@ -43,6 +56,7 @@ const SLACK_DELETE_ACTOR_ID = "U_DELETE_ACTOR";
 const SLACK_DELETE_ACTOR_DISPLAY_NAME = "Delete Actor";
 
 function resetState(): void {
+  publishedConversationIds.length = 0;
   const db = getDb();
   db.run("DELETE FROM channel_inbound_events");
   db.run("DELETE FROM messages");
@@ -223,6 +237,307 @@ describe("Discord delete propagation (unattributed)", () => {
     expect(neutral!.deletedAt).toBeDefined();
   });
 
+  test("deleting the assistant's own post stamps its row via the stored provider id", async () => {
+    // A moderator removing the assistant's reply: the post opened no inbound
+    // event, so resolution can only go through the provider id its row
+    // carries (stamped at reserve, reconciled at delivery). The retry window
+    // is not paid: no inbound event exists to wait on.
+    const chatId = "999888777666555444";
+    const sentId = "111222333444555777";
+    const minted = recordInbound("discord", chatId, "evt-earlier-user-msg");
+    const messageId = "assistant-reply-1";
+    getDb()
+      .insert(messages)
+      .values({
+        id: messageId,
+        conversationId: minted.conversationId,
+        role: "assistant",
+        content: "The reply a moderator later removed",
+        metadata: JSON.stringify({
+          assistantMessageChannel: "discord",
+          providerMeta: JSON.stringify({
+            source: "discord",
+            conversationExternalId: chatId,
+            messageId: sentId,
+            eventKind: "message",
+          }),
+        }),
+        createdAt: Date.now(),
+      })
+      .run();
+
+    const req = new Request("http://localhost:8080/channels/inbound", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "X-Gateway-Origin": TEST_BEARER_TOKEN,
+      },
+      body: JSON.stringify({
+        sourceChannel: "discord",
+        interface: "discord",
+        conversationExternalId: chatId,
+        externalMessageId: `${sentId}:delete`,
+        eventKind: "delete",
+        content: "",
+        actorExternalId: "discord-system",
+        sourceMetadata: {
+          messageId: sentId,
+          actorUnattributed: true,
+        },
+      }),
+    });
+    const resp = await handleChannelInbound(req, undefined, TEST_BEARER_TOKEN);
+    const json = (await resp.json()) as Record<string, unknown>;
+
+    expect(json.accepted).toBe(true);
+    expect(json.deleted).toBe(true);
+    expect(json.messageId).toBe(messageId);
+
+    const row = getDb()
+      .select()
+      .from(messages)
+      .where(eq(messages.id, messageId))
+      .get();
+    // Content survives: the stamp records loss of channel visibility, not an
+    // erasure of what the assistant said.
+    expect(row!.content).toBe("The reply a moderator later removed");
+    const neutral = readProviderMetadata(row!.metadata);
+    expect(neutral!.deletedAt).toBeDefined();
+    expect(neutral!.messageId).toBe(sentId);
+    expect(publishedConversationIds).toEqual([minted.conversationId]);
+  });
+
+  test("deleting one post of a split reply keeps the surviving posts live", async () => {
+    const chatId = "999888777666555444";
+    const minted = recordInbound("discord", chatId, "evt-split-seed");
+    const primaryId = "111222333444555801";
+    const additionalId = "111222333444555802";
+    getDb()
+      .insert(messages)
+      .values({
+        id: "assistant-split-reply",
+        conversationId: minted.conversationId,
+        role: "assistant",
+        content: "part one and part two",
+        metadata: JSON.stringify({
+          providerMeta: JSON.stringify({
+            source: "discord",
+            conversationExternalId: chatId,
+            messageId: primaryId,
+            additionalMessageIds: [additionalId],
+            eventKind: "message",
+          }),
+        }),
+        createdAt: Date.now(),
+      })
+      .run();
+
+    const deleteReq = (postId: string) =>
+      new Request("http://localhost:8080/channels/inbound", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "X-Gateway-Origin": TEST_BEARER_TOKEN,
+        },
+        body: JSON.stringify({
+          sourceChannel: "discord",
+          interface: "discord",
+          conversationExternalId: chatId,
+          externalMessageId: `${postId}:delete`,
+          eventKind: "delete",
+          content: "",
+          actorExternalId: "discord-system",
+          sourceMetadata: { messageId: postId, actorUnattributed: true },
+        }),
+      });
+
+    // Deleting the ADDITIONAL post: tracked per id, the row stays visible.
+    const first = await handleChannelInbound(
+      deleteReq(additionalId),
+      undefined,
+      TEST_BEARER_TOKEN,
+    );
+    expect(((await first.json()) as Record<string, unknown>).deleted).toBe(
+      true,
+    );
+    const afterFirst = readProviderMetadata(
+      getDb()
+        .select()
+        .from(messages)
+        .where(eq(messages.id, "assistant-split-reply"))
+        .get()!.metadata,
+    );
+    expect(afterFirst!.deletedMessageIds).toEqual([additionalId]);
+    expect(afterFirst!.deletedAt).toBeUndefined();
+
+    // Deleting the PRIMARY post too: every post is gone, the row-level
+    // marker lands.
+    const second = await handleChannelInbound(
+      deleteReq(primaryId),
+      undefined,
+      TEST_BEARER_TOKEN,
+    );
+    expect(((await second.json()) as Record<string, unknown>).deleted).toBe(
+      true,
+    );
+    const afterSecond = readProviderMetadata(
+      getDb()
+        .select()
+        .from(messages)
+        .where(eq(messages.id, "assistant-split-reply"))
+        .get()!.metadata,
+    );
+    expect(new Set(afterSecond!.deletedMessageIds)).toEqual(
+      new Set([additionalId, primaryId]),
+    );
+    expect(afterSecond!.deletedAt).toBeDefined();
+  });
+
+  test("a delete racing the outbound id reconciliation resolves on retry", async () => {
+    _setDeleteLookupConfigForTests(3, 30);
+    const chatId = "999888777666555444";
+    const sentId = "111222333444555803";
+    const minted = recordInbound("discord", chatId, "evt-race-seed");
+    // The pre-send stamp: the envelope names no id yet, exactly the state a
+    // fast automated deletion races.
+    getDb()
+      .insert(messages)
+      .values({
+        id: "assistant-racing-reply",
+        conversationId: minted.conversationId,
+        role: "assistant",
+        content: "posted a moment ago",
+        metadata: JSON.stringify({
+          providerMeta: JSON.stringify({
+            source: "discord",
+            conversationExternalId: chatId,
+            eventKind: "message",
+          }),
+        }),
+        createdAt: Date.now(),
+      })
+      .run();
+    // The post-send reconciliation lands while the delete lookup is in its
+    // backoff window.
+    setTimeout(() => {
+      getDb()
+        .update(messages)
+        .set({
+          metadata: JSON.stringify({
+            providerMeta: JSON.stringify({
+              source: "discord",
+              conversationExternalId: chatId,
+              messageId: sentId,
+              eventKind: "message",
+            }),
+          }),
+        })
+        .where(eq(messages.id, "assistant-racing-reply"))
+        .run();
+    }, 45);
+
+    const resp = await handleChannelInbound(
+      new Request("http://localhost:8080/channels/inbound", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "X-Gateway-Origin": TEST_BEARER_TOKEN,
+        },
+        body: JSON.stringify({
+          sourceChannel: "discord",
+          interface: "discord",
+          conversationExternalId: chatId,
+          externalMessageId: `${sentId}:delete`,
+          eventKind: "delete",
+          content: "",
+          actorExternalId: "discord-system",
+          sourceMetadata: { messageId: sentId, actorUnattributed: true },
+        }),
+      }),
+      undefined,
+      TEST_BEARER_TOKEN,
+    );
+    expect(((await resp.json()) as Record<string, unknown>).deleted).toBe(true);
+    const meta = readProviderMetadata(
+      getDb()
+        .select()
+        .from(messages)
+        .where(eq(messages.id, "assistant-racing-reply"))
+        .get()!.metadata,
+    );
+    expect(meta!.deletedAt).toBeDefined();
+  });
+
+  test("deleting an old post beyond the recency window resolves via the deep scan", async () => {
+    const chatId = "999888777666555444";
+    const oldId = "111222333444555804";
+    const minted = recordInbound("discord", chatId, "evt-old-seed");
+    const db = getDb();
+    db.insert(messages)
+      .values({
+        id: "assistant-old-post",
+        conversationId: minted.conversationId,
+        role: "assistant",
+        content: "an old reply",
+        metadata: JSON.stringify({
+          providerMeta: JSON.stringify({
+            source: "discord",
+            conversationExternalId: chatId,
+            messageId: oldId,
+            eventKind: "message",
+          }),
+        }),
+        createdAt: 1_000_000,
+      })
+      .run();
+    // Bury it under more metadata-bearing rows than the recency-capped
+    // reaction lookup examines.
+    const insert = db.$client.prepare(
+      `INSERT INTO messages (id, conversation_id, role, content, created_at, metadata)
+       VALUES (?, ?, 'user', 'filler', ?, ?)`,
+    );
+    for (let i = 0; i < 450; i++) {
+      insert.run(
+        `filler-${i}`,
+        minted.conversationId,
+        2_000_000 + i,
+        JSON.stringify({
+          providerMeta: JSON.stringify({
+            source: "discord",
+            conversationExternalId: chatId,
+            messageId: `filler-post-${i}`,
+            eventKind: "message",
+          }),
+        }),
+      );
+    }
+
+    const resp = await handleChannelInbound(
+      new Request("http://localhost:8080/channels/inbound", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "X-Gateway-Origin": TEST_BEARER_TOKEN,
+        },
+        body: JSON.stringify({
+          sourceChannel: "discord",
+          interface: "discord",
+          conversationExternalId: chatId,
+          externalMessageId: `${oldId}:delete`,
+          eventKind: "delete",
+          content: "",
+          actorExternalId: "discord-system",
+          sourceMetadata: { messageId: oldId, actorUnattributed: true },
+        }),
+      }),
+      undefined,
+      TEST_BEARER_TOKEN,
+    );
+    const json = (await resp.json()) as Record<string, unknown>;
+    expect(json.deleted).toBe(true);
+    expect(json.messageId).toBe("assistant-old-post");
+  });
+
   test("an unattributed delete for a never-ingested message is a no-op", async () => {
     const req = new Request("http://localhost:8080/channels/inbound", {
       method: "POST",
@@ -313,6 +628,160 @@ describe("Slack delete propagation", () => {
     expect(slackMeta!.channelTs).toBe("1234.5678");
     expect(slackMeta!.eventKind).toBe("message");
     expect(slackMeta!.displayName).toBe("Test User");
+    // A client showing the conversation is told to refetch.
+    expect(publishedConversationIds).toEqual([seeded.conversationId]);
+  });
+
+  test("deleting the assistant's own Slack post is recorded without an actor", async () => {
+    // Slack names a deleted post's author and never who deleted it, so the
+    // gateway forwards a deletion of the assistant's own post unattributed
+    // (LUM-3521). The post opened no inbound event; the row resolves through
+    // the `channelTs` its Slack envelope carries, and the stamp lands on
+    // that envelope, where the Slack renderers read it.
+    const chatId = "C0123CHANNEL";
+    const postTs = "1725100000.000900";
+    const minted = recordInbound("slack", chatId, "evt-earlier-user-msg");
+    const messageId = "assistant-slack-reply-1";
+    getDb()
+      .insert(messages)
+      .values({
+        id: messageId,
+        conversationId: minted.conversationId,
+        role: "assistant",
+        content: "The reply that was later deleted from the thread",
+        metadata: JSON.stringify({
+          assistantMessageChannel: "slack",
+          slackMeta: writeSlackMetadata({
+            source: "slack",
+            channelId: chatId,
+            channelTs: postTs,
+            threadTs: "1725100000.000100",
+            eventKind: "message",
+          }),
+        }),
+        createdAt: Date.now(),
+      })
+      .run();
+
+    const req = new Request("http://localhost:8080/channels/inbound", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "X-Gateway-Origin": TEST_BEARER_TOKEN,
+      },
+      body: JSON.stringify({
+        sourceChannel: "slack",
+        interface: "slack",
+        conversationExternalId: chatId,
+        externalMessageId: "evt-del-own-post",
+        eventKind: "delete",
+        content: "",
+        actorExternalId: "slack-system",
+        sourceMetadata: {
+          messageId: postTs,
+          threadId: "1725100000.000100",
+          actorUnattributed: true,
+        },
+      }),
+    });
+    const resp = await handleChannelInbound(req, undefined, TEST_BEARER_TOKEN);
+    const json = (await resp.json()) as Record<string, unknown>;
+
+    expect(json.accepted).toBe(true);
+    expect(json.deleted).toBe(true);
+    expect(json.messageId).toBe(messageId);
+
+    const row = getDb()
+      .select()
+      .from(messages)
+      .where(eq(messages.id, messageId))
+      .get();
+    // Content survives: the stamp records loss of channel visibility, not an
+    // erasure of what the assistant said.
+    expect(row!.content).toBe(
+      "The reply that was later deleted from the thread",
+    );
+    const parsed = JSON.parse(row!.metadata!) as Record<string, unknown>;
+    const slackMeta = readSlackMetadata(parsed.slackMeta as string);
+    expect(slackMeta!.deletedAt).toBeDefined();
+    expect(slackMeta!.channelTs).toBe(postTs);
+    expect(readProviderMetadata(row!.metadata)!.deletedAt).toBeDefined();
+  });
+
+  test("deleting the assistant's own Slack post stamps its neutral envelope per post", async () => {
+    // A Slack reply row carries the neutral envelope every channel writes,
+    // so its deletion takes the same per-post path as any channel's: the
+    // gateway forwards the delete unattributed (Slack names the author,
+    // never the deleter), the row resolves through the id its envelope
+    // names, and the Slack renderers read the stamp through the Slack view.
+    const chatId = "C0123CHANNEL";
+    const postTs = "1725100000.000900";
+    const minted = recordInbound("slack", chatId, "evt-earlier-user-msg");
+    const messageId = "assistant-slack-reply-1";
+    getDb()
+      .insert(messages)
+      .values({
+        id: messageId,
+        conversationId: minted.conversationId,
+        role: "assistant",
+        content: "The reply that was later deleted from the thread",
+        metadata: JSON.stringify({
+          assistantMessageChannel: "slack",
+          providerMeta: JSON.stringify({
+            source: "slack",
+            conversationExternalId: chatId,
+            messageId: postTs,
+            threadId: "1725100000.000100",
+            eventKind: "message",
+            timestampTimezone: "America/New_York",
+          }),
+        }),
+        createdAt: Date.now(),
+      })
+      .run();
+
+    const req = new Request("http://localhost:8080/channels/inbound", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "X-Gateway-Origin": TEST_BEARER_TOKEN,
+      },
+      body: JSON.stringify({
+        sourceChannel: "slack",
+        interface: "slack",
+        conversationExternalId: chatId,
+        externalMessageId: "evt-del-own-post",
+        eventKind: "delete",
+        content: "",
+        actorExternalId: "slack-system",
+        sourceMetadata: {
+          messageId: postTs,
+          threadId: "1725100000.000100",
+          actorUnattributed: true,
+        },
+      }),
+    });
+    const resp = await handleChannelInbound(req, undefined, TEST_BEARER_TOKEN);
+    const json = (await resp.json()) as Record<string, unknown>;
+    expect(json.accepted).toBe(true);
+    expect(json.deleted).toBe(true);
+    expect(json.messageId).toBe(messageId);
+
+    const row = getDb()
+      .select()
+      .from(messages)
+      .where(eq(messages.id, messageId))
+      .get();
+    expect(row!.content).toBe(
+      "The reply that was later deleted from the thread",
+    );
+    const neutral = readProviderMetadata(row!.metadata);
+    expect(neutral!.deletedMessageIds).toEqual([postTs]);
+    expect(neutral!.deletedAt).toBeDefined();
+    const view = readSlackMetadataFromMessageMetadata(row!.metadata);
+    expect(view!.channelTs).toBe(postTs);
+    expect(view!.deletedAt).toBe(neutral!.deletedAt);
+    expect(view!.timestampTimezone).toBe("America/New_York");
   });
 
   test("delete for unknown ts is a no-op", async () => {

package/src/__tests__/dm-persistence.test.ts

@@ -92,6 +92,7 @@ function createSlackTurnContext(): MessagingConversationContext {
     size: () => 0,
   } as unknown as MessageQueue;
   let processing = false;
+  let owner = 0;
   return {
     conversationId: "conv-dm-test",
     messages: [],
@@ -99,6 +100,21 @@ function createSlackTurnContext(): MessagingConversationContext {
     setProcessing: (value: boolean) => {
       processing = value;
     },
+    acquireProcessingFenced: async () => {
+      if (processing) {
+        return null;
+      }
+      processing = true;
+      owner += 1;
+      return owner;
+    },
+    releaseProcessing: (claim: number) => {
+      if (claim !== owner) {
+        return false;
+      }
+      processing = false;
+      return true;
+    },
     abortController: null,
     queue: queueStub,
     getTurnChannelContext: () => channel,

package/src/__tests__/docker-kata-apt-shims.test.ts

@@ -0,0 +1,135 @@
+import { execFileSync } from "node:child_process";
+import {
+  chmodSync,
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { basename, join } from "node:path";
+import { afterEach, describe, expect, test } from "bun:test";
+
+const scriptPath = join(
+  import.meta.dir,
+  "..",
+  "..",
+  "docker-kata-apt-shims.sh",
+);
+const testRoots: string[] = [];
+
+afterEach(() => {
+  for (const root of testRoots.splice(0)) {
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
+function writeExecutable(path: string, contents: string): void {
+  writeFileSync(path, contents);
+  chmodSync(path, 0o755);
+}
+
+function createDataRoot(): string {
+  const dataRoot = mkdtempSync(join(tmpdir(), "kata-apt-shims-"));
+  testRoots.push(dataRoot);
+  for (const dir of [
+    "usr/bin",
+    "usr/sbin",
+    "usr/games",
+    "usr/local/bin",
+    "usr/local/sbin",
+    "var/lib/dpkg",
+  ]) {
+    mkdirSync(join(dataRoot, dir), { recursive: true });
+  }
+  writeFileSync(join(dataRoot, "var/lib/dpkg/status"), "unchanged\n");
+  return dataRoot;
+}
+
+function refreshShims(dataRoot: string, pathPrefix?: string): void {
+  execFileSync("/bin/sh", [scriptPath], {
+    env: {
+      ...process.env,
+      PATH: pathPrefix
+        ? `${pathPrefix}:${process.env.PATH ?? ""}`
+        : process.env.PATH,
+      VELLUM_APT_DATA_ROOT: dataRoot,
+    },
+  });
+}
+
+describe("docker-kata-apt-shims", () => {
+  test.skipIf(process.platform !== "linux")(
+    "refreshes a shim when a same-version reinstall retargets its trampoline",
+    () => {
+      const dataRoot = createDataRoot();
+
+      const suffix = basename(dataRoot);
+      const firstTarget = `/vellum-apt-shim-test/${suffix}-1`;
+      const secondTarget = `/vellum-apt-shim-test/${suffix}-2`;
+      const source = join(dataRoot, "usr/bin/example-tool");
+      const shim = join(dataRoot, ".host-shims/example-tool");
+
+      for (const target of [firstTarget, secondTarget]) {
+        const chrootTarget = `${dataRoot}${target}`;
+        mkdirSync(join(chrootTarget, ".."), { recursive: true });
+        writeExecutable(chrootTarget, "#!/bin/sh\nexit 0\n");
+      }
+
+      writeExecutable(source, `#!/bin/sh\nexec ${firstTarget} "$@"\n`);
+      refreshShims(dataRoot);
+      expect(readFileSync(shim, "utf8")).toContain(firstTarget);
+
+      writeExecutable(source, `#!/bin/sh\nexec ${secondTarget} "$@"\n`);
+      const fakeBin = join(dataRoot, "fake-bin");
+      const failedOnce = join(dataRoot, "mv-failed-once");
+      mkdirSync(fakeBin);
+      writeExecutable(
+        join(fakeBin, "mv"),
+        `#!/bin/sh
+if [ ! -e "${failedOnce}" ]; then
+  touch "${failedOnce}"
+  exit 91
+fi
+[ -f "$3" ] || exit 92
+exec /bin/mv "$@"
+`,
+      );
+
+      expect(() => refreshShims(dataRoot, fakeBin)).toThrow();
+      expect(readFileSync(shim, "utf8")).toContain(firstTarget);
+      refreshShims(dataRoot, fakeBin);
+
+      const refreshedShim = readFileSync(shim, "utf8");
+      expect(refreshedShim).toContain(secondTarget);
+      expect(refreshedShim).not.toContain(firstTarget);
+    },
+  );
+
+  test.skipIf(process.platform !== "linux")(
+    "ignores non-executable entries and refreshes when they become runnable",
+    () => {
+      const dataRoot = createDataRoot();
+      const suffix = basename(dataRoot);
+      const target = `/vellum-apt-shim-test/${suffix}`;
+      const chrootTarget = `${dataRoot}${target}`;
+      const lowerSource = join(dataRoot, "usr/sbin/example-tool");
+      const higherSource = join(dataRoot, "usr/local/bin/example-tool");
+      const shim = join(dataRoot, ".host-shims/example-tool");
+
+      mkdirSync(join(chrootTarget, ".."), { recursive: true });
+      writeExecutable(chrootTarget, "#!/bin/sh\nexit 0\n");
+      writeExecutable(lowerSource, `#!/bin/sh\nexec ${target} "$@"\n`);
+      writeFileSync(higherSource, "#!/bin/sh\nexit 0\n", { mode: 0o644 });
+
+      refreshShims(dataRoot);
+      expect(readFileSync(shim, "utf8")).toContain(target);
+
+      chmodSync(higherSource, 0o755);
+      refreshShims(dataRoot);
+      expect(existsSync(shim)).toBe(false);
+    },
+  );
+});

package/src/__tests__/forbidden-legacy-symbols.test.ts

@@ -34,11 +34,23 @@ describe("forbidden legacy symbols", () => {
       "twilio_webhook_config",
       "calls.webhookBaseUrl",
     ];
+    // This pattern is POSIX ERE for `git grep -E`, not a JavaScript RegExp:
+    // ERE has no `\x` escapes, so `RegExp.escape` would turn the pattern
+    // into one that matches nothing and the test would pass empty.
     const escapedPattern = forbiddenSymbols
       .map((symbol) => symbol.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"))
       .join("|");
 
     const repoRoot = resolve(__dirname, "..", "..", "..");
+    // Positive control: the pattern must still match the symbols as written
+    // in this very file, so a broken pattern fails loudly instead of
+    // matching nothing.
+    const selfMatches = execSync(
+      `git grep -c -E "${escapedPattern}" -- "assistant/src/__tests__/forbidden-legacy-symbols.test.ts"`,
+      { cwd: repoRoot, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] },
+    );
+    expect(selfMatches.trim()).not.toBe("");
+
     let matches = "";
     try {
       // Use git grep so only tracked files are searched. This automatically