@vellumai/assistant 0.11.0 → 0.11.1-dev.202608010027.2cfe358

package/src/runtime/routes/tool-call-question-enrichment.ts

@@ -54,10 +54,14 @@ export function enrichToolCallsWithQuestion(
   toolCalls: ConversationMessageToolCall[],
   opts: { pendingQuestions: ReadonlyMap<string, PendingQuestionMatch> },
 ): ConversationMessageToolCall[] {
-  if (opts.pendingQuestions.size === 0) return toolCalls;
+  if (opts.pendingQuestions.size === 0) {
+    return toolCalls;
+  }
   return toolCalls.map((tc) => {
     const match = tc.id ? opts.pendingQuestions.get(tc.id) : undefined;
-    if (!match) return tc;
+    if (!match) {
+      return tc;
+    }
     return {
       ...tc,
       pendingQuestion: { requestId: match.requestId, entries: match.entries },

package/src/runtime/routes/user-route-dispatcher.ts

@@ -14,12 +14,17 @@
  *   each other.
  *
  * Each handler file exports named functions for HTTP methods (GET, POST, PUT,
- * etc.) using the standard Web API Request/Response signature.
+ * etc.) using the standard Web API Request/Response signature. New handlers
+ * reach daemon capabilities by importing `@vellumai/plugin-api` (e.g.
+ * `publishEvent`, `runConversationTurn`), which broker process-safe access — so
+ * a handler behaves identically in-process and in the route-host subprocess.
  *
- * Handlers receive a second `context` argument with runtime singletons
- * (event hub, etc.) that would otherwise be unreachable from dynamically
- * imported modules because Bun's cache-busting import creates separate
- * module instances.
+ * For backward compatibility, the in-process path still passes a **deprecated**
+ * `context` second argument (see `deprecated-route-context.ts`): a thin shim
+ * over those same plugin-api calls that records a deprecation-usage telemetry
+ * signal so remaining callers can be found and migrated. The route-host path
+ * does not supply it. The argument is transitional and removed once telemetry
+ * shows no route depends on it.
  *
  * Modules are lazily loaded on first request and cached by file path +
  * mtime. When a file changes on disk, the next request reloads it via
@@ -36,8 +41,11 @@ import {
   RouteHostUnavailableError,
 } from "../../routes/route-host-client.js";
 import { getLogger } from "../../util/logger.js";
-import type { AssistantEventHub } from "../assistant-event-hub.js";
 import { httpError } from "../http-errors.js";
+import {
+  buildDeprecatedRouteContext,
+  type UserRouteContext,
+} from "./deprecated-route-context.js";
 import {
   resolveHandlerFile,
   resolveRouteLocation,
@@ -45,51 +53,6 @@ import {
 
 const log = getLogger("user-routes");
 
-// ---------------------------------------------------------------------------
-// User route context — injected into every handler as the second argument
-// ---------------------------------------------------------------------------
-
-/**
- * Runtime context passed to user-defined route handlers.
- *
- * Because user route modules are loaded via dynamic `import()` with
- * cache-busting query parameters, they get isolated module instances
- * and cannot import process-level singletons like the event hub
- * directly. This context bridges the gap by carrying references to
- * the daemon's real singletons.
- */
-export interface UserRouteContext {
-  /** The daemon's event hub singleton — use this to publish events to connected SSE clients. */
-  readonly assistantEventHub: AssistantEventHub;
-  /** Conversation operations available to route handlers (e.g. posting integration events as turns). */
-  readonly conversations: RouteConversationsApi;
-}
-
-/**
- * Conversation operations exposed to route handlers. Lets integration routes
- * (webhook receivers, cron jobs, device/service callbacks) surface an inbound
- * event as a real assistant turn rather than only a client-side event.
- */
-export interface RouteConversationsApi {
-  /**
-   * Post a message into an existing conversation as a real assistant turn.
-   *
-   * The turn is attributed to a dedicated integration interface (never a human
-   * surface) and runs under the conversation's existing trust context — a
-   * route cannot impersonate a user or elevate privilege by posting. Unknown
-   * conversation ids are rejected (a route never silently creates one), and
-   * posts are rate-limited per conversation to backstop runaway loops.
-   *
-   * Rejects with a `RouteMessageError` carrying `code`
-   * (`"not_found" | "rate_limited" | "invalid"`) — catch it to map to an HTTP
-   * status, or let it surface as a 500.
-   */
-  postMessage(
-    conversationId: string,
-    text: string,
-  ): Promise<{ messageId: string }>;
-}
-
 // ---------------------------------------------------------------------------
 // Route handler types
 // ---------------------------------------------------------------------------
@@ -108,12 +71,11 @@ const HTTP_METHODS = [
 type HttpMethod = (typeof HTTP_METHODS)[number];
 
 /**
- * The function signature that user-defined route handlers must follow.
- *
- * Handlers may accept an optional second `context` argument with runtime
- * singletons (event hub). Legacy handlers that only accept `request`
- * continue to work — the context is passed positionally but ignored if
- * the handler doesn't declare the parameter.
+ * The function signature that user-defined route handlers must follow. New
+ * handlers take just the `Request` and reach daemon state through
+ * `@vellumai/plugin-api`. A deprecated `context` second argument is still passed
+ * on the in-process path for backward compatibility (see
+ * `deprecated-route-context.ts`); handlers that omit the parameter ignore it.
  */
 type RouteHandler = (
   request: Request,
@@ -136,7 +98,6 @@ const DEFAULT_HANDLER_TIMEOUT_MS = 120_000;
 export class UserRouteDispatcher {
   private moduleCache = new Map<string, CachedModule>();
   private handlerTimeoutMs: number;
-  private context: UserRouteContext;
   /**
    * The route host client. Constructing it is inert — the subprocess spawns
    * lazily on the client's first `invoke` — so a dispatcher whose host is never
@@ -144,13 +105,9 @@ export class UserRouteDispatcher {
    */
   private readonly routeHostClient: RouteHostClient;
 
-  constructor(options: {
-    handlerTimeoutMs?: number;
-    context: UserRouteContext;
-  }) {
+  constructor(options: { handlerTimeoutMs?: number } = {}) {
     this.handlerTimeoutMs =
       options.handlerTimeoutMs ?? DEFAULT_HANDLER_TIMEOUT_MS;
-    this.context = Object.freeze({ ...options.context });
     // Both execution paths — in-process ({@link executeHandler}) and the route
     // host subprocess — must honor the same per-request timeout, so the host
     // client's hard-kill deadline is driven by the dispatcher's timeout rather
@@ -324,7 +281,9 @@ export class UserRouteDispatcher {
   ): Promise<Response> {
     try {
       const result = await Promise.race([
-        Promise.resolve(handler(request, this.context)),
+        Promise.resolve(
+          handler(request, buildDeprecatedRouteContext(routePath)),
+        ),
         new Promise<never>((_, reject) =>
           setTimeout(
             () => reject(new Error("Handler timed out")),

package/src/runtime/routes/user-routes-cli.ts

@@ -107,7 +107,9 @@ async function discoverRoutes(routesDir: string): Promise<DiscoveredRoute[]> {
         const ext = HANDLER_EXTENSIONS.find((e) => entry.name.endsWith(e)) as
           | HandlerExtension
           | undefined;
-        if (!ext) continue;
+        if (!ext) {
+          continue;
+        }
 
         const relativePath = relative(routesDir, fullPath);
         const withoutExt = relativePath.slice(0, -ext.length);

package/src/runtime/routes/user-routes.ts

@@ -15,21 +15,12 @@
  * over both HTTP and IPC.
  */
 
-import { postRouteConversationMessage } from "../../daemon/route-conversation-post.js";
-import { assistantEventHub } from "../assistant-event-hub.js";
 import { ACTOR_PRINCIPALS } from "../auth/route-policy.js";
 import type { RouteDefinition, RouteHandlerArgs } from "./types.js";
 import { RouteResponse } from "./types.js";
 import { UserRouteDispatcher } from "./user-route-dispatcher.js";
 
-const dispatcher = new UserRouteDispatcher({
-  context: {
-    assistantEventHub,
-    conversations: {
-      postMessage: postRouteConversationMessage,
-    },
-  },
-});
+const dispatcher = new UserRouteDispatcher();
 
 /**
  * Reconstruct a Web API `Request` from transport-agnostic handler args.

package/src/runtime/routes/watcher-routes.ts

@@ -134,11 +134,21 @@ function handleWatcherUpdate({ body = {} }: RouteHandlerArgs) {
     configJson?: string | null;
   } = {};
 
-  if (name !== undefined) updates.name = name;
-  if (actionPrompt !== undefined) updates.actionPrompt = actionPrompt;
-  if (pollIntervalMs !== undefined) updates.pollIntervalMs = pollIntervalMs;
-  if (enabled !== undefined) updates.enabled = enabled;
-  if (config !== undefined) updates.configJson = JSON.stringify(config);
+  if (name !== undefined) {
+    updates.name = name;
+  }
+  if (actionPrompt !== undefined) {
+    updates.actionPrompt = actionPrompt;
+  }
+  if (pollIntervalMs !== undefined) {
+    updates.pollIntervalMs = pollIntervalMs;
+  }
+  if (enabled !== undefined) {
+    updates.enabled = enabled;
+  }
+  if (config !== undefined) {
+    updates.configJson = JSON.stringify(config);
+  }
 
   if (Object.keys(updates).length === 0) {
     throw new BadRequestError(

package/src/runtime/routes/workflow-routes.test.ts

@@ -25,7 +25,9 @@ import { __setWorkflowRoutesDeps, ROUTES } from "./workflow-routes.js";
 
 function route(operationId: string): RouteDefinition {
   const r = ROUTES.find((x) => x.operationId === operationId);
-  if (!r) throw new Error(`No route for ${operationId}`);
+  if (!r) {
+    throw new Error(`No route for ${operationId}`);
+  }
   return r;
 }
 
@@ -112,8 +114,12 @@ function setup(opts: {
     list: (o) => {
       listCalls.push({ limit: o?.limit, status: o?.status });
       let result = runs;
-      if (o?.status) result = result.filter((r) => r.status === o.status);
-      if (o?.limit !== undefined) result = result.slice(0, o.limit);
+      if (o?.status) {
+        result = result.filter((r) => r.status === o.status);
+      }
+      if (o?.limit !== undefined) {
+        result = result.slice(0, o.limit);
+      }
       return result;
     },
     status: (id) => runs.find((r) => r.id === id) ?? null,

package/src/runtime/routes/workflow-routes.ts

@@ -162,7 +162,9 @@ export function toWireRun(run: WorkflowRun): WorkflowRunWire {
  * JSON-stringified so a structured result still produces a readable summary.
  */
 function summarize(value: unknown, max = 200): string | undefined {
-  if (value === undefined || value === null) return undefined;
+  if (value === undefined || value === null) {
+    return undefined;
+  }
   let text: string;
   if (typeof value === "string") {
     text = value;
@@ -215,16 +217,22 @@ export function toWireLeaf(
 }
 
 function parseLimit(raw: string | undefined): number | undefined {
-  if (raw === undefined) return undefined;
+  if (raw === undefined) {
+    return undefined;
+  }
   const n = Number(raw);
-  if (!Number.isFinite(n)) return undefined;
+  if (!Number.isFinite(n)) {
+    return undefined;
+  }
   return Math.min(Math.max(Math.floor(n), 1), 200);
 }
 
 function parseStatus(
   raw: string | undefined,
 ): WorkflowRun["status"] | undefined {
-  if (raw === undefined) return undefined;
+  if (raw === undefined) {
+    return undefined;
+  }
   return (VALID_RUN_STATUSES as readonly string[]).includes(raw)
     ? (raw as WorkflowRun["status"])
     : undefined;

package/src/runtime/routes/workspace-greetings.ts

@@ -5,7 +5,9 @@ import { getWorkspacePromptPath } from "../../util/platform.js";
 function readWorkspaceFile(name: string): string {
   try {
     const path = getWorkspacePromptPath(name);
-    if (!existsSync(path)) return "";
+    if (!existsSync(path)) {
+      return "";
+    }
     return readFileSync(path, "utf-8");
   } catch {
     return "";
@@ -28,7 +30,9 @@ export function parseGreetingsSection(content: string): string[] | null {
       const level = heading[1]!.length;
       const title = heading[2]!.trim();
       if (inSection) {
-        if (sectionLevel !== null && level <= sectionLevel) break;
+        if (sectionLevel !== null && level <= sectionLevel) {
+          break;
+        }
         continue;
       }
       if (level === 2 && /^greetings$/i.test(title)) {
@@ -37,7 +41,9 @@ export function parseGreetingsSection(content: string): string[] | null {
       }
       continue;
     }
-    if (!inSection) continue;
+    if (!inSection) {
+      continue;
+    }
     const bullet = /^(?:[-*+]\s+|\d+[.)]\s+)(.+)$/.exec(trimmed);
     const greeting = bullet?.[1]?.trim();
     if (greeting) {
@@ -50,6 +56,8 @@ export function parseGreetingsSection(content: string): string[] | null {
 
 export function readWorkspaceGreetings(): string[] | null {
   const soulContent = readWorkspaceFile("SOUL.md");
-  if (!soulContent) return null;
+  if (!soulContent) {
+    return null;
+  }
   return parseGreetingsSection(soulContent);
 }

package/src/runtime/routes/workspace-routes.ts

@@ -85,7 +85,9 @@ interface DirSizeBudget {
  * directories purely to discover their type.
  */
 function computeDirSize(absPath: string, budget: DirSizeBudget): number | null {
-  if (budget.remaining <= 0) return null;
+  if (budget.remaining <= 0) {
+    return null;
+  }
 
   let total = 0;
   const stack: string[] = [absPath];
@@ -101,7 +103,9 @@ function computeDirSize(absPath: string, budget: DirSizeBudget): number | null {
     }
 
     for (const entry of dirents) {
-      if (budget.remaining <= 0) return null;
+      if (budget.remaining <= 0) {
+        return null;
+      }
       budget.remaining -= 1;
 
       if (entry.isDirectory()) {
@@ -196,7 +200,9 @@ function handleWorkspaceTree({ queryParams }: RouteHandlerArgs) {
 
     const entries: TreeEntry[] = [];
     for (const entry of dirents) {
-      if (!showHidden && entry.name.startsWith(".")) continue;
+      if (!showHidden && entry.name.startsWith(".")) {
+        continue;
+      }
 
       const fullPath = join(resolved, entry.name);
 
@@ -316,7 +322,9 @@ function handleWorkspaceFileContent({
       throw new BadRequestError("Path is not a file");
     }
   } catch (err) {
-    if (err instanceof BadRequestError) throw err;
+    if (err instanceof BadRequestError) {
+      throw err;
+    }
     throw new NotFoundError("File not found");
   }
 

package/src/runtime/routes/workspace-utils.ts

@@ -54,7 +54,9 @@ export function resolveWorkspacePath(
 
     while (true) {
       const parent = resolve(ancestor, "..");
-      if (parent === ancestor) break; // reached filesystem root
+      if (parent === ancestor) {
+        break;
+      } // reached filesystem root
       ancestor = parent;
       try {
         const realAncestor = realpathSync(ancestor);
@@ -172,7 +174,9 @@ export function isTextMimeType(mimeType: string, fileName?: string): boolean {
   // trusted over the extension — overriding them risks corrupting binary files.
   if (fileName && mimeType === "application/octet-stream") {
     const ext = fileName.split(".").pop()?.toLowerCase();
-    if (ext && TEXT_FILE_EXTENSIONS.has(ext)) return true;
+    if (ext && TEXT_FILE_EXTENSIONS.has(ext)) {
+      return true;
+    }
   }
   return false;
 }

package/src/runtime/services/conversation-serializer.ts

@@ -13,6 +13,7 @@ import {
   type AttentionState,
   type Confidence,
   getAttentionStateByConversationIds,
+  hasUnseenLatestAssistantMessage,
   type SignalType,
 } from "../../persistence/conversation-attention-store.js";
 import {
@@ -37,14 +38,13 @@ function buildAssistantAttention(attentionState: AttentionState | undefined):
       lastSeenSignalType?: SignalType;
     }
   | undefined {
-  if (!attentionState) return undefined;
+  if (!attentionState) {
+    return undefined;
+  }
 
   return {
     hasUnseenLatestAssistantMessage:
-      attentionState.latestAssistantMessageAt != null &&
-      (attentionState.lastSeenAssistantMessageAt == null ||
-        attentionState.lastSeenAssistantMessageAt <
-          attentionState.latestAssistantMessageAt),
+      hasUnseenLatestAssistantMessage(attentionState),
     ...(attentionState.latestAssistantMessageAt != null
       ? {
           latestAssistantMessageAt: attentionState.latestAssistantMessageAt,
@@ -70,7 +70,9 @@ function buildForkParent(
 ): { conversationId: string; messageId: string; title: string } | undefined {
   const parentConversationId = conversation.forkParentConversationId;
   const parentMessageId = conversation.forkParentMessageId;
-  if (!parentConversationId || !parentMessageId) return undefined;
+  if (!parentConversationId || !parentMessageId) {
+    return undefined;
+  }
 
   let parentConversation: ConversationRow | null | undefined =
     parentCache.get(parentConversationId);
@@ -109,7 +111,9 @@ function resolveSerializedGroupId(
   conversation: ConversationRow,
   persistedGroupId: string | null,
 ): string | null {
-  if (conversation.surfacedAt == null) return persistedGroupId;
+  if (conversation.surfacedAt == null) {
+    return persistedGroupId;
+  }
   if (
     persistedGroupId == null ||
     persistedGroupId === "system:background" ||

package/src/runtime/slack-reply-session.test.ts

@@ -351,7 +351,9 @@ describe("createSlackReplySession", () => {
   test("falls back when stopStream throws after streaming text", async () => {
     deliverImpl = async (_url, payload) => {
       const op = payload.slackStream as { action: string };
-      if (op.action === "stop") {throw new Error("stop failed");}
+      if (op.action === "stop") {
+        throw new Error("stop failed");
+      }
       return { ok: true, ts: "stream-ts-1" };
     };
     const session = createSlackReplySession({

package/src/runtime/slack-reply-session.ts

@@ -79,12 +79,18 @@ export function shouldStreamSlackReply(params: {
   recipientUserId?: string;
   recipientTeamId?: string;
 }): boolean {
-  if (params.sourceChannel !== "slack") {return false;}
-  if (!isSlackDeliveryCallbackUrl(params.replyCallbackUrl)) {return false;}
+  if (params.sourceChannel !== "slack") {
+    return false;
+  }
+  if (!isSlackDeliveryCallbackUrl(params.replyCallbackUrl)) {
+    return false;
+  }
   if (extractThreadTsFromCallbackUrl(params.replyCallbackUrl) === null) {
     return false;
   }
-  if (params.chatType === "im") {return true;}
+  if (params.chatType === "im") {
+    return true;
+  }
   return Boolean(params.recipientUserId && params.recipientTeamId);
 }
 
@@ -130,7 +136,9 @@ export function createSlackReplySession(params: {
   const coalesceMs = params.coalesceMs ?? STREAM_COALESCE_MS;
   const replyCallbackUrl = params.replyCallbackUrl;
   const threadTs = extractThreadTsFromCallbackUrl(replyCallbackUrl);
-  if (threadTs === null) {return undefined;}
+  if (threadTs === null) {
+    return undefined;
+  }
 
   let state: StreamState = "idle";
   let started = false;
@@ -172,7 +180,9 @@ export function createSlackReplySession(params: {
   // (and `stripVellumLinks` can remove it). Once `finished`, no delta can
   // extend the text, so the full cleaned reply is safe to emit.
   const streamableText = (): string => {
-    if (finished) {return cleanedText();}
+    if (finished) {
+      return cleanedText();
+    }
     const hold = incompleteVellumLinkSuffixLength(rawText);
     const stable = hold > 0 ? rawText.slice(0, rawText.length - hold) : rawText;
     return stripVellumLinks(stable).replace(NO_RESPONSE_INLINE_RE, "");
@@ -205,7 +215,9 @@ export function createSlackReplySession(params: {
   const enqueueStart = (): void => {
     enqueue(async () => {
       const clean = streamableText();
-      if (clean.trim().length === 0) {return;}
+      if (clean.trim().length === 0) {
+        return;
+      }
       const firstChunk = clean.slice(0, SLACK_STREAM_MARKDOWN_LIMIT);
       const title = activeProgress?.title;
       const tasks = planTasks();
@@ -259,7 +271,9 @@ export function createSlackReplySession(params: {
 
   const enqueueAppend = (): void => {
     enqueue(async () => {
-      if (state !== "streaming" || !streamTs) {return;}
+      if (state !== "streaming" || !streamTs) {
+        return;
+      }
       const clean = streamableText();
       const title = activeProgress?.title;
       const tasks = planTasks();
@@ -329,9 +343,13 @@ export function createSlackReplySession(params: {
       clearTimeout(coalesceTimer);
       coalesceTimer = undefined;
     }
-    if (finished || state === "fallback") {return;}
+    if (finished || state === "fallback") {
+      return;
+    }
     if (!started) {
-      if (!hasDeliverableAssistantText(streamableText())) {return;}
+      if (!hasDeliverableAssistantText(streamableText())) {
+        return;
+      }
       started = true;
       enqueueStart();
       return;
@@ -340,7 +358,9 @@ export function createSlackReplySession(params: {
   };
 
   const scheduleFlush = (): void => {
-    if (coalesceTimer || finished) {return;}
+    if (coalesceTimer || finished) {
+      return;
+    }
     coalesceTimer = setTimeout(() => {
       coalesceTimer = undefined;
       flush();
@@ -359,12 +379,16 @@ export function createSlackReplySession(params: {
   const observeTaskProgress = (msg: AssistantEvent): void => {
     if (msg.type === "ui_surface_show") {
       const progress = getTaskProgressDataFromSurfaceData(msg.data);
-      if (!progress) {return;}
+      if (!progress) {
+        return;
+      }
       taskProgressBySurfaceId.set(msg.surfaceId, progress);
     } else if (msg.type === "ui_surface_update") {
       const existing = taskProgressBySurfaceId.get(msg.surfaceId);
       const progress = mergeTaskProgressData(existing, msg.data);
-      if (!progress) {return;}
+      if (!progress) {
+        return;
+      }
       taskProgressBySurfaceId.set(msg.surfaceId, progress);
     } else {
       return;
@@ -375,7 +399,9 @@ export function createSlackReplySession(params: {
 
   return {
     observeEvent(msg) {
-      if (finished) {return;}
+      if (finished) {
+        return;
+      }
 
       if (msg.type === "ui_surface_show" || msg.type === "ui_surface_update") {
         observeTaskProgress(msg);
@@ -415,7 +441,9 @@ export function createSlackReplySession(params: {
 
       enqueueAppend();
       enqueue(async () => {
-        if (state !== "streaming" || !streamTs) {return;}
+        if (state !== "streaming" || !streamTs) {
+          return;
+        }
         const clean = cleanedText();
         const remaining = clean.slice(confirmedLength);
         const blocks = imageBlocks(clean);

package/src/runtime/trust-verdict-consumer.ts

@@ -219,8 +219,12 @@ export interface VerdictMember {
 export function verdictMemberFromVerdict(
   verdict: TrustVerdict,
 ): VerdictMember | null {
-  if (!verdict.contactId || !verdict.channelId) return null;
-  if (!verdict.status || !verdict.policy) return null;
+  if (!verdict.contactId || !verdict.channelId) {
+    return null;
+  }
+  if (!verdict.status || !verdict.policy) {
+    return null;
+  }
   if (!isChannelStatus(verdict.status) || !isChannelPolicy(verdict.policy)) {
     return null;
   }
@@ -246,7 +250,9 @@ function memberRecordFromVerdict(
   verdict: TrustVerdict,
 ): ActorTrustContext["memberRecord"] {
   const member = verdictMemberFromVerdict(verdict);
-  if (!member) return null;
+  if (!member) {
+    return null;
+  }
 
   const channel: ContactChannel = {
     id: member.channelId,

package/src/runtime/verification-outbound-actions.ts

@@ -80,7 +80,9 @@ function isTelegramChatId(destination: string): boolean {
  * Numeric chat IDs are returned as-is.
  */
 export function normalizeTelegramDestination(destination: string): string {
-  if (isTelegramChatId(destination)) return destination;
+  if (isTelegramChatId(destination)) {
+    return destination;
+  }
   return destination.replace(/^@/, "").toLowerCase();
 }
 

package/src/runtime/verification-rate-limiter.ts

@@ -30,7 +30,9 @@ class VerificationRateLimiter {
         this.evictStale(now);
         if (this.failures.size >= MAX_TRACKED_IDENTITIES) {
           const oldest = this.failures.keys().next().value;
-          if (oldest !== undefined) this.failures.delete(oldest);
+          if (oldest !== undefined) {
+            this.failures.delete(oldest);
+          }
         }
       }
       timestamps = [];
@@ -43,7 +45,9 @@ class VerificationRateLimiter {
   /** Returns true if the identity has exceeded the failure threshold. */
   isBlocked(identity: string): boolean {
     const timestamps = this.failures.get(identity);
-    if (!timestamps) return false;
+    if (!timestamps) {
+      return false;
+    }
 
     const now = Date.now();
     const cutoff = now - this.windowMs;