@vellumai/assistant 0.11.0 → 0.11.1-staging.2

package/src/__tests__/subagent-tools.test.ts

@@ -64,7 +64,14 @@ mock.module("../persistence/conversation-crud.js", () => ({
   reserveMessage: mock(async () => ({ id: "msg-reserve" })),
 }));
 
+import { getDb } from "../persistence/db-connection.js";
 import { resolveMessageContentBlocks } from "../persistence/message-content-file.js";
+import { migrateCreateSubagentsTable } from "../persistence/migrations/311-create-subagents-table.js";
+import { migrateAddSubagentParentToolUseId } from "../persistence/migrations/356-add-subagent-parent-tool-use-id.js";
+import {
+  type SubagentRecord,
+  upsertSubagentRecord,
+} from "../persistence/subagent-store.js";
 import { getSubagentManager } from "../subagent/index.js";
 import { SubagentAbortedError, SubagentManager } from "../subagent/manager.js";
 import type { SubagentState } from "../subagent/types.js";
@@ -74,6 +81,12 @@ import { executeSubagentRead } from "../tools/subagent/read.js";
 import { executeSubagentSpawn } from "../tools/subagent/spawn.js";
 import { executeSubagentStatus } from "../tools/subagent/status.js";
 
+// The tools fall back to the durable table for a subagent the manager does not
+// hold, so every executor here reaches it. Idempotent; the table may already
+// exist from a prior run.
+migrateCreateSubagentsTable();
+migrateAddSubagentParentToolUseId(getDb());
+
 // Load tool definitions from the bundled skill TOOLS.json
 const toolsJson = JSON.parse(
   readFileSync(
@@ -2050,3 +2063,294 @@ describe("subagent tools — model-input schema validation", () => {
     expect(passthrough.content).toContain("required");
   });
 });
+
+// ── Durable fallback past the rehydration bound ─────────────────────
+
+/** Mirrors `MAX_REHYDRATED_TERMINAL_RECORDS` in `subagent/manager.ts`. */
+const REHYDRATION_CAP = 200;
+
+const beyondCapParent = "beyond-cap-parent";
+const beyondCapOtherParent = "beyond-cap-other-parent";
+const reusedLabel = "Reused beyond cap";
+
+function terminalRecord(over: Partial<SubagentRecord>): SubagentRecord {
+  return {
+    id: "seed",
+    parentConversationId: beyondCapParent,
+    conversationId: "conv-seed",
+    label: "seed",
+    objective: "seeded objective",
+    role: "general",
+    isFork: false,
+    sendResultToUser: true,
+    parentToolUseId: null,
+    status: "completed",
+    error: null,
+    createdAt: 1,
+    startedAt: 2,
+    completedAt: 3,
+    inputTokens: 11,
+    outputTokens: 22,
+    estimatedCost: 0.33,
+    ...over,
+  };
+}
+
+describe("Subagent tools past the startup rehydration bound", () => {
+  // Two runs reused one label, both older than a full cap's worth of finished
+  // subagents, so the rehydration leaves them out of memory entirely.
+  upsertSubagentRecord(
+    terminalRecord({
+      id: "reused-cap-old",
+      conversationId: "conv-reused-cap-old",
+      label: reusedLabel,
+      createdAt: 1_000,
+      completedAt: 2_000,
+    }),
+  );
+  upsertSubagentRecord(
+    terminalRecord({
+      id: "reused-cap-new",
+      conversationId: "conv-reused-cap-new",
+      label: reusedLabel,
+      createdAt: 3_000,
+      completedAt: 4_000,
+    }),
+  );
+  for (let i = 0; i < REHYDRATION_CAP; i++) {
+    upsertSubagentRecord(
+      terminalRecord({
+        id: `cap-filler-${i}`,
+        conversationId: `conv-cap-filler-${i}`,
+        label: `cap filler ${i}`,
+        createdAt: 10_000 + i,
+        completedAt: 20_000 + i,
+      }),
+    );
+  }
+
+  const manager = getSubagentManager();
+  manager.rehydrateFromDb();
+
+  test("the rehydration really left the older runs out of memory", () => {
+    expect(manager.getState("reused-cap-new")).toBeUndefined();
+    expect(manager.getState("reused-cap-old")).toBeUndefined();
+    expect(manager.getByLabel(reusedLabel, beyondCapParent)).toBeUndefined();
+  });
+
+  test("status answers for a subagent the bound left in the table", async () => {
+    const result = await executeSubagentStatus(
+      { subagent_id: "reused-cap-new" },
+      makeContext(beyondCapParent),
+    );
+    expect(result.isError).toBe(false);
+    const parsed = JSON.parse(result.content);
+    expect(parsed.subagentId).toBe("reused-cap-new");
+    expect(parsed.label).toBe(reusedLabel);
+    expect(parsed.status).toBe("completed");
+    expect(parsed.usage).toEqual({
+      inputTokens: 11,
+      outputTokens: 22,
+      estimatedCost: 0.33,
+    });
+  });
+
+  test("status still rejects another conversation asking for it", async () => {
+    const result = await executeSubagentStatus(
+      { subagent_id: "reused-cap-new" },
+      makeContext(beyondCapOtherParent),
+    );
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain("No subagent found");
+  });
+
+  test("read returns the transcript for a subagent past the bound", async () => {
+    mockGetMessages = (convId: string) => {
+      if (convId !== "conv-reused-cap-new") {
+        return null;
+      }
+      return [
+        {
+          role: "assistant",
+          content: [{ type: "text", text: "Output from beyond the bound" }],
+        },
+      ];
+    };
+
+    try {
+      const result = await executeSubagentRead(
+        { subagent_id: "reused-cap-new" },
+        makeContext(beyondCapParent),
+      );
+      expect(result.isError).toBe(false);
+      expect(result.content).toBe("Output from beyond the bound");
+    } finally {
+      mockGetMessages = () => null;
+    }
+  });
+
+  test("read still rejects another conversation asking for it", async () => {
+    mockGetMessages = () => [
+      { role: "assistant", content: [{ type: "text", text: "leaked" }] },
+    ];
+
+    try {
+      const result = await executeSubagentRead(
+        { subagent_id: "reused-cap-new" },
+        makeContext(beyondCapOtherParent),
+      );
+      expect(result.isError).toBe(true);
+      expect(result.content).toContain("No subagent found");
+      expect(result.content).not.toContain("leaked");
+    } finally {
+      mockGetMessages = () => null;
+    }
+  });
+
+  test("a label past the bound resolves durably to the newest run", async () => {
+    const result = await executeSubagentStatus(
+      { label: reusedLabel },
+      makeContext(beyondCapParent),
+    );
+    expect(result.isError).toBe(false);
+    expect(JSON.parse(result.content).subagentId).toBe("reused-cap-new");
+  });
+
+  test("a label past the bound matches case- and space-insensitively", async () => {
+    const result = await executeSubagentStatus(
+      { label: `  ${reusedLabel.toUpperCase()}  ` },
+      makeContext(beyondCapParent),
+    );
+    expect(result.isError).toBe(false);
+    expect(JSON.parse(result.content).subagentId).toBe("reused-cap-new");
+  });
+
+  test("a label past the bound stays scoped to the parent that spawned it", async () => {
+    const result = await executeSubagentStatus(
+      { label: reusedLabel },
+      makeContext(beyondCapOtherParent),
+    );
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain("No subagent found");
+  });
+});
+
+// ── List-all merges live children with durable rows ─────────────────
+
+describe("subagent_status list-all past the in-memory window", () => {
+  const mergeParent = "list-merge-parent";
+
+  // A run the retention sweep evicted from memory while keeping its row, plus
+  // a stale row for a subagent the manager still holds live.
+  upsertSubagentRecord(
+    terminalRecord({
+      id: "list-merge-swept",
+      parentConversationId: mergeParent,
+      conversationId: "conv-list-merge-swept",
+      label: "Swept worker",
+      createdAt: 1_000,
+      completedAt: 2_000,
+    }),
+  );
+  upsertSubagentRecord(
+    terminalRecord({
+      id: "list-merge-live",
+      parentConversationId: mergeParent,
+      conversationId: "conv-list-merge-live",
+      label: "Live worker",
+      createdAt: 3_000,
+      completedAt: 4_000,
+    }),
+  );
+
+  const listMergeManager = getSubagentManager();
+  injectSubagent(listMergeManager, "list-merge-live", mergeParent, "running");
+
+  function listedSubagents(content: string) {
+    return JSON.parse(content) as Array<{ subagentId: string; status: string }>;
+  }
+
+  test("lists a swept subagent alongside the live one", async () => {
+    const result = await executeSubagentStatus({}, makeContext(mergeParent));
+    expect(result.isError).toBe(false);
+    expect(
+      listedSubagents(result.content)
+        .map((s) => s.subagentId)
+        .sort(),
+    ).toEqual(["list-merge-live", "list-merge-swept"]);
+  });
+
+  test("prefers live state over the row, and settles a row-only entry", async () => {
+    const result = await executeSubagentStatus({}, makeContext(mergeParent));
+    const listed = listedSubagents(result.content);
+
+    // The row says `completed`; the manager is still running it.
+    expect(listed.find((s) => s.subagentId === "list-merge-live")?.status).toBe(
+      "running",
+    );
+    expect(
+      listed.find((s) => s.subagentId === "list-merge-swept")?.status,
+    ).toBe("completed");
+  });
+});
+
+// ── List-all bounds the merged set ──────────────────────────────────
+
+/** Mirrors `MAX_LISTED_TERMINAL_RECORDS` in `tools/subagent/status.ts`. */
+const LISTED_TERMINAL_CAP = 20;
+
+describe("subagent_status list-all bounds the terminal entries", () => {
+  const boundParent = "list-bound-parent";
+
+  // A restart rehydrates far more terminal children than this path reports, so
+  // the bound has to hold over the merged set, not just the durable query.
+  for (let i = 0; i < 25; i++) {
+    injectSubagent(
+      getSubagentManager(),
+      `list-bound-done-${String(i).padStart(2, "0")}`,
+      boundParent,
+      "completed",
+      { createdAt: 1_000 + i, completedAt: 10_000 + i },
+    );
+  }
+  // The oldest child of the parent, which the recency cap must not reach.
+  injectSubagent(
+    getSubagentManager(),
+    "list-bound-active",
+    boundParent,
+    "running",
+    {
+      createdAt: 1,
+    },
+  );
+
+  function listedIds(content: string): string[] {
+    return (JSON.parse(content) as Array<{ subagentId: string }>).map(
+      (s) => s.subagentId,
+    );
+  }
+
+  test("reports only the most recently settled terminal children", async () => {
+    const result = await executeSubagentStatus({}, makeContext(boundParent));
+    expect(result.isError).toBe(false);
+
+    expect(
+      listedIds(result.content)
+        .filter((id) => id !== "list-bound-active")
+        .sort(),
+    ).toEqual(
+      Array.from(
+        { length: LISTED_TERMINAL_CAP },
+        (_, i) => `list-bound-done-${String(i + 5).padStart(2, "0")}`,
+      ).sort(),
+    );
+  });
+
+  test("never caps out an active child, however old", async () => {
+    const result = await executeSubagentStatus({}, makeContext(boundParent));
+    const ids = listedIds(result.content);
+
+    expect(ids).toContain("list-bound-active");
+    expect(ids).toHaveLength(LISTED_TERMINAL_CAP + 1);
+  });
+});

package/src/__tests__/system-prompt.test.ts

@@ -106,7 +106,9 @@ describe("buildSystemPrompt", () => {
       "channels",
     ]) {
       const p = join(TEST_DIR, name);
-      if (existsSync(p)) rmSync(p, { recursive: true, force: true });
+      if (existsSync(p)) {
+        rmSync(p, { recursive: true, force: true });
+      }
     }
   });
 
@@ -617,8 +619,9 @@ describe("buildSystemPrompt", () => {
     const PREFIX_FRONTMATTER = '---\nenabled: "!excludeCustomPrefix"\n---\n';
 
     afterEach(() => {
-      if (existsSync(SYSTEM_PROMPTS_DIR))
+      if (existsSync(SYSTEM_PROMPTS_DIR)) {
         rmSync(SYSTEM_PROMPTS_DIR, { recursive: true, force: true });
+      }
     });
 
     test("no workspace section files → bundled defaults render directly", () => {
@@ -945,9 +948,11 @@ describe("buildSystemPrompt", () => {
       });
 
       afterEach(() => {
-        if (priorIsContainerized === undefined)
+        if (priorIsContainerized === undefined) {
           delete process.env.IS_CONTAINERIZED;
-        else process.env.IS_CONTAINERIZED = priorIsContainerized;
+        } else {
+          process.env.IS_CONTAINERIZED = priorIsContainerized;
+        }
       });
 
       test("renders the section when IS_CONTAINERIZED=true with {{workspaceDir}} interpolated", () => {
@@ -1392,7 +1397,9 @@ describe("ensurePromptFiles", () => {
       "users",
     ]) {
       const p = join(TEST_DIR, name);
-      if (existsSync(p)) rmSync(p, { recursive: true, force: true });
+      if (existsSync(p)) {
+        rmSync(p, { recursive: true, force: true });
+      }
     }
   });
 

package/src/__tests__/task-progress-nudge-hook.test.ts

@@ -125,7 +125,9 @@ function turnWithRounds(
     } else {
       messages.push(toolUseTurn(id, "bash", { command: `cmd-${r}` }));
     }
-    if (r < rounds) messages.push(toolResultTurn(id));
+    if (r < rounds) {
+      messages.push(toolResultTurn(id));
+    }
   }
   return { messages, currentToolUseId: `tool-${rounds}` };
 }

package/src/__tests__/telegram-bot-username-resolution.test.ts

@@ -66,7 +66,9 @@ beforeEach(() => {
 
   globalThis.fetch = (async (..._args: unknown[]) => {
     fetchCallCount++;
-    if (mockFetchThrows) throw mockFetchThrows;
+    if (mockFetchThrows) {
+      throw mockFetchThrows;
+    }
     return mockFetchResponse;
   }) as typeof globalThis.fetch;
 });

package/src/__tests__/telegram-config.test.ts

@@ -73,7 +73,9 @@ mock.module("../oauth/manual-token-connection.js", () => ({
   removeManualTokenConnection: () => {},
   syncManualTokenConnection: async (provider: string, accountInfo?: string) => {
     syncCalls.push({ provider, accountInfo });
-    if (provider !== "telegram") return;
+    if (provider !== "telegram") {
+      return;
+    }
     const hasBotToken =
       !!secureKeyStore[credentialKey("telegram", "bot_token")];
     const hasWebhookSecret =

package/src/__tests__/telemetry-routes.test.ts

@@ -37,7 +37,9 @@ const VALID_FIELDS = {
   claims_confident: 1,
   claims_maybe: 0,
   claims_guessing: 0,
-  suggestions: [{ suggestion: "I'll find 3 papers", prompt: "Find me 3 papers" }],
+  suggestions: [
+    { suggestion: "I'll find 3 papers", prompt: "Find me 3 papers" },
+  ],
   suggestion_count: 1,
   plugins: ["marketing-expert"],
   installed_plugins: ["marketing-expert", "web-research"],
@@ -142,8 +144,11 @@ describe("telemetry-routes: ingest", () => {
 
   test("rejects malformed fields (missing or mistyped) without persisting", () => {
     // Missing the required derived counts.
-    const { claim_count: _c, suggestion_count: _s, ...missingCounts } =
-      VALID_FIELDS;
+    const {
+      claim_count: _c,
+      suggestion_count: _s,
+      ...missingCounts
+    } = VALID_FIELDS;
     expect(() =>
       call({ type: "onboarding_research", fields: missingCounts }),
     ).toThrow(RouteError);

package/src/__tests__/thinking-block-replay.test.ts

@@ -39,8 +39,7 @@ describe.skipIf(!apiKey)(
       expect(thinkingBlock!.signature).toBeTruthy();
 
       // Step 2: Tamper with the signature to simulate a stale/cross-provider block
-      const tamperedSignature =
-        thinkingBlock!.signature.slice(0, -4) + "XXXX";
+      const tamperedSignature = thinkingBlock!.signature.slice(0, -4) + "XXXX";
 
       // Step 3: Replay the tampered block as historical context
       const historicalAssistantContent: Anthropic.ContentBlockParam[] = [

package/src/__tests__/thread-backfill.test.ts

@@ -74,8 +74,12 @@ mock.module("../messaging/providers/slack/adapter.js", () => ({
     _account: string | undefined,
     botId: string,
   ) => {
-    if (botId === "B_ASSISTANT") return "U_BOT";
-    if (botId === "B_OTHER") return "U_OTHER_BOT";
+    if (botId === "B_ASSISTANT") {
+      return "U_BOT";
+    }
+    if (botId === "B_OTHER") {
+      return "U_OTHER_BOT";
+    }
     return null;
   },
 }));
@@ -2241,12 +2245,16 @@ describe("handleChannelInbound — Slack thread backfill wiring", () => {
 
     const channelTimestamps = new Set<string>();
     for (const row of rows) {
-      if (!row.metadata) continue;
+      if (!row.metadata) {
+        continue;
+      }
       try {
         const envelope = JSON.parse(row.metadata) as Record<string, unknown>;
         if (typeof envelope.slackMeta === "string") {
           const slackMeta = readSlackMetadata(envelope.slackMeta);
-          if (slackMeta) channelTimestamps.add(slackMeta.channelTs);
+          if (slackMeta) {
+            channelTimestamps.add(slackMeta.channelTs);
+          }
         }
       } catch {
         // ignore
@@ -2680,10 +2688,14 @@ describe("handleChannelInbound — Slack thread backfill wiring", () => {
       .all() as Array<{ metadata: string | null }>;
     const tsBefore = rowsBeforeResolve
       .map((row) => {
-        if (!row.metadata) return undefined;
+        if (!row.metadata) {
+          return undefined;
+        }
         try {
           const env = JSON.parse(row.metadata) as Record<string, unknown>;
-          if (typeof env.slackMeta !== "string") return undefined;
+          if (typeof env.slackMeta !== "string") {
+            return undefined;
+          }
           const meta = readSlackMetadata(env.slackMeta);
           return meta?.channelTs;
         } catch {
@@ -2704,10 +2716,14 @@ describe("handleChannelInbound — Slack thread backfill wiring", () => {
       .all() as Array<{ metadata: string | null }>;
     const tsAfter = rowsAfter
       .map((row) => {
-        if (!row.metadata) return undefined;
+        if (!row.metadata) {
+          return undefined;
+        }
         try {
           const env = JSON.parse(row.metadata) as Record<string, unknown>;
-          if (typeof env.slackMeta !== "string") return undefined;
+          if (typeof env.slackMeta !== "string") {
+            return undefined;
+          }
           const meta = readSlackMetadata(env.slackMeta);
           return meta?.channelTs;
         } catch {

package/src/__tests__/token-estimator-accuracy.benchmark.test.ts

@@ -264,7 +264,9 @@ function makeSystemPrompt(size: "small" | "production" = "small"): string {
     while (sections.join("\n").length < 35000) {
       for (const g of guidelines) {
         sections.push(`- ${g}`);
-        if (sections.join("\n").length >= 35000) break;
+        if (sections.join("\n").length >= 35000) {
+          break;
+        }
       }
     }
   }
@@ -1054,7 +1056,9 @@ function generateBundledSkillTools(
           `The ${pName} parameter for ${cat} ${action} operation. ` +
           `Used to ${action} ${cat} items matching the specified criteria.`,
       };
-      if (p < 2) required.push(pName); // First 2 params are required
+      if (p < 2) {
+        required.push(pName);
+      } // First 2 params are required
     }
 
     tools.push({

package/src/__tests__/token-manager.test.ts

@@ -93,7 +93,9 @@ mock.module("../oauth/oauth-store.js", () => ({
   getConnectionByProvider: (service: string) => mockConnections.get(service),
   getConnection: (id: string) => {
     for (const conn of mockConnections.values()) {
-      if (conn.id === id) return conn;
+      if (conn.id === id) {
+        return conn;
+      }
     }
     return undefined;
   },
@@ -221,7 +223,9 @@ describe("withValidToken refresh deduplication", () => {
     const err401 = Object.assign(new Error("Unauthorized"), { status: 401 });
 
     const callback = async (token: string) => {
-      if (token === "old-access-token") throw err401;
+      if (token === "old-access-token") {
+        throw err401;
+      }
       return `result-with-${token}`;
     };
 
@@ -281,18 +285,24 @@ describe("withValidToken refresh deduplication", () => {
       refreshCallCount++;
       // Both services use the same tokenExchangeUrl in this test, so we track by
       // call order to return the correct deferred promise.
-      if (refreshCallCount === 1) return gmailPromise;
+      if (refreshCallCount === 1) {
+        return gmailPromise;
+      }
       return slackPromise;
     });
 
     const err401 = Object.assign(new Error("Unauthorized"), { status: 401 });
 
     const gmailCallback = async (token: string) => {
-      if (token === "old-access-token") throw err401;
+      if (token === "old-access-token") {
+        throw err401;
+      }
       return `gmail-${token}`;
     };
     const slackCallback = async (token: string) => {
-      if (token === "old-access-token") throw err401;
+      if (token === "old-access-token") {
+        throw err401;
+      }
       return `slack-${token}`;
     };
 
@@ -330,7 +340,9 @@ describe("withValidToken refresh deduplication", () => {
 
     // First call triggers a refresh (old token → 401 → refresh → token-1)
     const r1 = await withValidToken("google", async (token: string) => {
-      if (token !== "token-1") throw err401;
+      if (token !== "token-1") {
+        throw err401;
+      }
       return token;
     });
     expect(r1).toBe("token-1");
@@ -339,7 +351,9 @@ describe("withValidToken refresh deduplication", () => {
     // Second call also triggers a 401 to verify dedup state was cleaned up
     // and a new refresh is allowed (not deduplicated with the first).
     const r2 = await withValidToken("google", async (token: string) => {
-      if (token !== "token-2") throw err401;
+      if (token !== "token-2") {
+        throw err401;
+      }
       return token;
     });
     expect(r2).toBe("token-2");
@@ -362,7 +376,9 @@ describe("withValidToken refresh deduplication", () => {
     const err401 = Object.assign(new Error("Unauthorized"), { status: 401 });
 
     const callback = async (token: string) => {
-      if (token === "old-access-token") throw err401;
+      if (token === "old-access-token") {
+        throw err401;
+      }
       return "should-not-reach";
     };
 
@@ -398,7 +414,9 @@ describe("withValidToken refresh deduplication", () => {
       const err401 = Object.assign(new Error("Unauthorized"), { status: 401 });
 
       const callback = async (token: string) => {
-        if (token === "old-access-token") throw err401;
+        if (token === "old-access-token") {
+          throw err401;
+        }
         return `result-with-${token}`;
       };
 
@@ -429,7 +447,9 @@ describe("withValidToken refresh deduplication", () => {
       const err401 = Object.assign(new Error("Unauthorized"), { status: 401 });
 
       const callback = async (token: string) => {
-        if (token === "old-access-token") throw err401;
+        if (token === "old-access-token") {
+          throw err401;
+        }
         return `result-with-${token}`;
       };
 
@@ -461,7 +481,9 @@ describe("withValidToken refresh deduplication", () => {
       const err401 = Object.assign(new Error("Unauthorized"), { status: 401 });
 
       const callback = async (token: string) => {
-        if (token === "old-access-token") throw err401;
+        if (token === "old-access-token") {
+          throw err401;
+        }
         return `result-with-${token}`;
       };
 
@@ -493,7 +515,9 @@ describe("withValidToken refresh deduplication", () => {
       const err401 = Object.assign(new Error("Unauthorized"), { status: 401 });
 
       const callback = async (token: string) => {
-        if (token === "old-access-token") throw err401;
+        if (token === "old-access-token") {
+          throw err401;
+        }
         return `result-with-${token}`;
       };
 

package/src/__tests__/tool-preview-lifecycle.test.ts

@@ -73,12 +73,9 @@ mock.module("../plugins/defaults/memory/memory-recall-log-store.js", () => ({
   backfillMemoryRecallLogMessageId: () => {},
 }));
 
-mock.module(
-  "../plugins/defaults/memory/v2/activation-log-store.js",
-  () => ({
-    backfillMemoryV2ActivationMessageId: () => {},
-  }),
-);
+mock.module("../plugins/defaults/memory/v2/activation-log-store.js", () => ({
+  backfillMemoryV2ActivationMessageId: () => {},
+}));
 
 // ── Imports (after mocks) ─────────────────────────────────────────────────────
 import type { AgentEvent } from "../agent/loop.js";

package/src/__tests__/tool-result-truncation.test.ts

@@ -13,7 +13,9 @@ function hasOrphanedSurrogate(str: string): boolean {
     const code = str.charCodeAt(i);
     if (code >= 0xd800 && code <= 0xdbff) {
       const next = i + 1 < str.length ? str.charCodeAt(i + 1) : 0;
-      if (next < 0xdc00 || next > 0xdfff) return true;
+      if (next < 0xdc00 || next > 0xdfff) {
+        return true;
+      }
       i++;
     } else if (code >= 0xdc00 && code <= 0xdfff) {
       return true;