@vellumai/assistant 0.10.12 → 0.11.0-staging.1

package/src/plugins/defaults/memory/v2/activation.ts

@@ -12,18 +12,11 @@
 //               + c_user      · α · r_norm(User_{t+1},  n)   [n ∈ topK]
 //               + c_assistant · α · r_norm(Assistant_t, n)   [n ∈ topK]
 //
-//   A(n, t+1) = [ A_o(n)
-//               + k  · Σ_{m∈in1(n)} A_o(m)
-//               + k² · Σ_{m∈in2(n)} A_o(m) ]
-//             / (1 + k · #in1(n) + k² · #in2(n))
-//
-// Edges are directed: edge A→B means A's activation contributes to B's. The
-// per-target BFS walks *incoming* adjacency, so `in1(n)` is the set of nodes
-// with an edge A→n and `in2(n)` adds another hop in the same direction.
-//
-// Bounded in [0, 1]. Pure sources (no incoming edges within `hops`) reduce to
-// A == A_o because both numerator and denominator collapse to `A_o(n)` and
-// `1`, respectively.
+// The spread step that turns A_o into the final A(n, t+1) lives in the
+// substrate (`substrate/spread.ts` — `spreadActivation`) because the `memory`
+// recall source also spreads activation under v3. Callers import it from there
+// directly; this module deliberately does not re-export it, so the symbol has
+// one import path.
 //
 // Candidate selection (§6) keeps the per-turn cost linear in the size of the
 // active set rather than the entire concept-page collection. The candidate
@@ -38,14 +31,10 @@ import type { AssistantConfig } from "../../../../config/types.js";
 import { isEmbeddingDimensionAvailable } from "../../../../persistence/embeddings/embedding-backend.js";
 import { applyCorrectionIfCalibrated } from "../anisotropy.js";
 import { embedWithBackend } from "../embeddings.js";
-import type { EdgeIndex } from "../v3/substrate/edge-index.js";
-import { hybridQueryConceptPages } from "../v3/substrate/qdrant.js";
-import { simBatch } from "../v3/substrate/sim.js";
-import { generateBm25QueryEmbedding } from "../v3/substrate/sparse-bm25.js";
-import type {
-  ActivationState,
-  EverInjectedEntry,
-} from "../v3/substrate/types.js";
+import { hybridQueryConceptPages } from "../substrate/qdrant.js";
+import { simBatch } from "../substrate/sim.js";
+import { generateBm25QueryEmbedding } from "../substrate/sparse-bm25.js";
+import type { ActivationState, EverInjectedEntry } from "../substrate/types.js";
 import { clampUnitInterval } from "../validation.js";
 import { rerankCandidates } from "./reranker.js";
 
@@ -121,7 +110,9 @@ export async function selectCandidates(
   if (priorState) {
     const epsilon = config.memory.v2.epsilon;
     for (const [slug, activation] of Object.entries(priorState.state)) {
-      if (activation > epsilon) fromPrior.add(slug);
+      if (activation > epsilon) {
+        fromPrior.add(slug);
+      }
     }
   }
 
@@ -157,7 +148,9 @@ export async function selectCandidates(
     const limit =
       config.memory.v2.ann_candidate_limit ?? UNLIMITED_ANN_CANDIDATE_LIMIT;
     const hits = await hybridQueryConceptPages(dense, sparse, limit);
-    for (const hit of hits) fromAnn.add(hit.slug);
+    for (const hit of hits) {
+      fromAnn.add(hit.slug);
+    }
   }
 
   const candidates = new Set<string>([...fromPrior, ...fromAnn]);
@@ -243,7 +236,9 @@ export async function computeOwnActivation(
 
   const activation = new Map<string, number>();
   const breakdown = new Map<string, OwnActivationBreakdown>();
-  if (candidates.size === 0) return { activation, breakdown };
+  if (candidates.size === 0) {
+    return { activation, breakdown };
+  }
 
   const { d, c_user, c_assistant, c_now } = config.memory.v2;
   const slugList = [...candidates];
@@ -358,12 +353,18 @@ function normalizeRerankScores(
   alpha: number,
 ): Map<string, number> {
   const out = new Map<string, number>();
-  if (rawScores.size === 0) return out;
+  if (rawScores.size === 0) {
+    return out;
+  }
   let maxScore = 0;
   for (const v of rawScores.values()) {
-    if (v > maxScore) maxScore = v;
+    if (v > maxScore) {
+      maxScore = v;
+    }
+  }
+  if (maxScore === 0) {
+    return out;
   }
-  if (maxScore === 0) return out;
   for (const [slug, raw] of rawScores) {
     out.set(slug, alpha * (raw / maxScore));
   }
@@ -376,142 +377,6 @@ function throwIfAborted(signal: AbortSignal | undefined): void {
   }
 }
 
-// ---------------------------------------------------------------------------
-// Spreading activation
-// ---------------------------------------------------------------------------
-
-interface SpreadActivationResult {
-  /** Final activation value per slug after spreading. */
-  final: Map<string, number>;
-  /**
-   * Per-slug spread delta: `final[slug] - own[slug]`. Captures how much
-   * the spread step nudged each node above (or below) its own activation —
-   * useful for inspector views that want to show graph contributions
-   * separate from raw sim contributions. Always 0 when `hops == 0` or
-   * `k == 0` because both short-circuit to `final == own`.
-   */
-  contribution: Map<string, number>;
-}
-
-/**
- * Apply 2-hop spreading activation with neighborhood normalization. Edges are
- * directed: an edge A→B means A's activation contributes to B's final value.
- *
- *   A(n) = [ A_o(n) + Σ_{r: |active_inR(n)| > 0} k^r · L2(active_inR(n)) ]
- *        / [ 1     + Σ_{r: |active_inR(n)| > 0} k^r ]
- *
- * `active_inR(n)` is the subset of structural predecessors at hop `r` that
- * also appear in `ownActivation` (i.e. made the candidate set). `L2(.)` is
- * the quadratic mean √(mean(A_o²)) — a mild bias toward strong outliers
- * compared to the arithmetic mean, without letting a single high-cosine
- * predecessor dominate the way `max` would.
- *
- * Hops with **no** active predecessors are dropped from BOTH numerator and
- * denominator so a high-in-degree hub with mostly-inactive neighbors stays
- * near `A_o` instead of being crushed by the structural count. A pure
- * source (no incoming edges, or every edge points at a non-candidate)
- * collapses to `A == A_o`.
- *
- * Bounded in [0, 1]: every `L2` term ≤ max active A_o ≤ 1, so the numerator
- * is at most `1 + Σ k^r` — exactly the denominator — so the ratio is at most
- * 1. `clampUnitInterval` guards against numerical drift and out-of-range
- * inputs.
- *
- * Pure function — no I/O. Reads the precomputed `incoming` map from
- * `edgeIndex` and runs a per-source BFS bounded by `hops`.
- */
-export function spreadActivation(
-  ownActivation: ReadonlyMap<string, number>,
-  edgeIndex: EdgeIndex,
-  k: number,
-  hops: number,
-): SpreadActivationResult {
-  const final = new Map<string, number>();
-  const contribution = new Map<string, number>();
-  if (ownActivation.size === 0) return { final, contribution };
-
-  // Short-circuit: with no spread the formula collapses to A == A_o.
-  if (hops <= 0 || k <= 0) {
-    for (const [slug, ownValue] of ownActivation) {
-      final.set(slug, clampUnitInterval(ownValue));
-      contribution.set(slug, 0);
-    }
-    return { final, contribution };
-  }
-
-  for (const [slug, ownValue] of ownActivation) {
-    // Single bounded BFS from `slug` over incoming edges. `distance` maps
-    // predecessor → hop count (1..hops). Source is excluded so it contributes
-    // hop-0 only via `numerator = ownValue`.
-    const distance = bfsPredecessorDistances(edgeIndex.incoming, slug, hops);
-
-    // Bucket only predecessors that are in `ownActivation` (the candidate
-    // set). Structural predecessors that didn't make the cut contribute
-    // nothing — neither to the numerator nor the denominator — so hub
-    // in-degree alone never penalizes a node.
-    const ringActiveCounts: number[] = new Array(hops + 1).fill(0);
-    const ringSquareSums: number[] = new Array(hops + 1).fill(0);
-    for (const [predecessor, hop] of distance) {
-      const predValue = ownActivation.get(predecessor);
-      if (predValue === undefined) continue;
-      ringActiveCounts[hop] += 1;
-      ringSquareSums[hop] += predValue * predValue;
-    }
-
-    let numerator = ownValue;
-    let denominator = 1;
-    let kPow = 1;
-    for (let r = 1; r <= hops; r++) {
-      kPow *= k;
-      if (ringActiveCounts[r] === 0) continue;
-      const rms = Math.sqrt(ringSquareSums[r] / ringActiveCounts[r]);
-      numerator += kPow * rms;
-      denominator += kPow;
-    }
-
-    const finalValue = clampUnitInterval(numerator / denominator);
-    final.set(slug, finalValue);
-    contribution.set(slug, finalValue - ownValue);
-  }
-
-  return { final, contribution };
-}
-
-// ---------------------------------------------------------------------------
-// Internal helpers
-// ---------------------------------------------------------------------------
-
-/**
- * Bounded BFS over the *incoming* adjacency map. Returns each reachable
- * predecessor's hop-distance in [1, maxHops] from `target` — i.e. nodes from
- * which a directed path of that length leads into `target`. The target itself
- * is excluded.
- */
-function bfsPredecessorDistances(
-  incoming: ReadonlyMap<string, ReadonlySet<string>>,
-  target: string,
-  maxHops: number,
-): Map<string, number> {
-  const distance = new Map<string, number>();
-  let frontier: string[] = [target];
-  const visited = new Set<string>([target]);
-  for (let hop = 1; hop <= maxHops && frontier.length > 0; hop++) {
-    const next: string[] = [];
-    for (const node of frontier) {
-      const predecessors = incoming.get(node);
-      if (!predecessors) continue;
-      for (const predecessor of predecessors) {
-        if (visited.has(predecessor)) continue;
-        visited.add(predecessor);
-        distance.set(predecessor, hop);
-        next.push(predecessor);
-      }
-    }
-    frontier = next;
-  }
-  return distance;
-}
-
 // ---------------------------------------------------------------------------
 // Injection selection
 // ---------------------------------------------------------------------------
@@ -549,7 +414,9 @@ export function selectInjections(
   }
 
   const ranked = [...A.entries()].sort(([slugA, valA], [slugB, valB]) => {
-    if (valB !== valA) return valB - valA; // higher activation first
+    if (valB !== valA) {
+      return valB - valA;
+    } // higher activation first
     return slugA < slugB ? -1 : slugA > slugB ? 1 : 0; // stable tie-break
   });
 

package/src/plugins/defaults/memory/v2/backfill-jobs.ts

@@ -2,21 +2,18 @@
 // Memory v2 — Backfill job handlers
 // ---------------------------------------------------------------------------
 //
-// Three operator-triggered backfills, all wired through the same job queue so
+// Two operator-triggered v2 backfills, wired through the same job queue so
 // they can be enqueued from the IPC route, the CLI, or recovery paths:
 //
 //   - `memory_v2_migrate`              — one-shot v1→v2 synthesis (PR 16).
-//   - `memory_v2_reembed`              — fan out an `embed_concept_page` job
-//     per concept-page slug.
 //   - `memory_v2_activation_recompute` — recompute persisted activation
 //     state for every conversation, no rendering. Used after consolidation
 //     replaces or deletes pages that other conversations still reference.
 //
 // Each handler is intentionally small — heavy lifting lives in the modules
-// they delegate to (`migration.ts`, `page-store.ts`, `embed-concept-page.ts`,
-// `activation.ts`, `activation-store.ts`). Keeping the wrappers thin means
-// the same code paths exercised by tests of those modules run unchanged when
-// a backfill kicks them off.
+// they delegate to (`migration.ts`, `activation.ts`, `activation-store.ts`).
+// Keeping the wrappers thin means the same code paths exercised by tests of
+// those modules run unchanged when a backfill kicks them off.
 
 import {
   getMessages,
@@ -27,16 +24,11 @@ import {
 import type { AssistantConfig } from "../../../../config/types.js";
 import { getMemoryDb } from "../../../../persistence/db-connection.js";
 import type { MemoryJob } from "../../../../persistence/jobs-store.js";
-import { enqueueEmbedConceptPageJob } from "../jobs/embed-concept-page.js";
 import { getLogger } from "../logging.js";
 import { getWorkspaceDir } from "../paths.js";
-import { getEdgeIndex } from "../v3/substrate/edge-index.js";
-import { listPages } from "../v3/substrate/page-store.js";
-import {
-  computeOwnActivation,
-  selectCandidates,
-  spreadActivation,
-} from "./activation.js";
+import { getEdgeIndex } from "../substrate/edge-index.js";
+import { spreadActivation } from "../substrate/spread.js";
+import { computeOwnActivation, selectCandidates } from "./activation.js";
 import { hydrate, save } from "./activation-store.js";
 import {
   MigrationAlreadyAppliedError,
@@ -101,45 +93,6 @@ export async function memoryV2MigrateJob(
   }
 }
 
-// ---------------------------------------------------------------------------
-// memory_v2_reembed — fan out embed jobs for every concept page
-// ---------------------------------------------------------------------------
-
-/**
- * Job handler: enqueue an `embed_concept_page` job per concept-page slug.
- * Each enqueue coalesces with an already-pending job for the same slug, so
- * stacked reembed runs converge on at most one pending embed per page.
- *
- * Returns the number of pages fanned out (enqueue attempts, not necessarily
- * fresh rows). Callers (and tests) use the return value to assert progress
- * without inspecting the job table directly.
- *
- * Note on meta files: `essentials.md` / `threads.md` / `recent.md` /
- * `buffer.md` are direct-injected into the system prompt every turn via
- * `_autoinject.md`. They are NOT enqueued for embedding here — their slugs
- * (`__essentials__` etc.) contain underscores that the concept-page slug
- * validator rejects (`[a-z0-9][a-z0-9-]*`), and they live at `memory/<name>.md`
- * rather than `memory/concepts/<name>.md`, so path resolution would also miss.
- * Embedding them would be redundant with the direct injection regardless.
- */
-export async function memoryV2ReembedJob(
-  _job: MemoryJob,
-  _config: AssistantConfig,
-): Promise<number> {
-  const workspaceDir = getWorkspaceDir();
-  const slugs = await listPages(workspaceDir);
-
-  for (const slug of slugs) {
-    enqueueEmbedConceptPageJob({ slug });
-  }
-
-  log.info(
-    { conceptPages: slugs.length, total: slugs.length },
-    "Memory v2 reembed enqueued",
-  );
-  return slugs.length;
-}
-
 // ---------------------------------------------------------------------------
 // memory_v2_activation_recompute — refresh persisted activation state
 // ---------------------------------------------------------------------------

package/src/plugins/defaults/memory/{memory-v2-concept-frequency.ts → v2/concept-frequency.ts}

@@ -1,6 +1,6 @@
-import { memorySqliteOrNull } from "./memory-db.js";
-import type { MemoryV2ConceptRowRecord } from "./memory-v2-activation-log-store.js";
-import { listPages } from "./v3/substrate/page-store.js";
+import { memorySqliteOrNull } from "../memory-db.js";
+import { listPages } from "../substrate/page-store.js";
+import type { MemoryV2ConceptRowRecord } from "./activation-log-store.js";
 
 type ConceptStatus = MemoryV2ConceptRowRecord["status"];
 

package/src/plugins/defaults/memory/v2/harness/oracle.ts

@@ -23,7 +23,7 @@ import { memorySqliteOrNull } from "../../memory-db.js";
 import type {
   MemoryV2ConceptRowRecord,
   MemoryV2ConfigSnapshot,
-} from "../../memory-v2-activation-log-store.js";
+} from "../activation-log-store.js";
 
 export interface OracleTurn {
   conversationId: string;

package/src/plugins/defaults/memory/v2/harness/replay-input.ts

@@ -27,8 +27,8 @@ import type { AssistantConfig } from "../../../../../config/types.js";
 import type { DrizzleDb } from "../../../../../persistence/db-connection.js";
 import { messages } from "../../../../../persistence/schema/index.js";
 import { memorySqliteOrNull } from "../../memory-db.js";
-import type { MemoryV2ConceptRowRecord } from "../../memory-v2-activation-log-store.js";
-import type { EverInjectedEntry } from "../../v3/substrate/types.js";
+import type { EverInjectedEntry } from "../../substrate/types.js";
+import type { MemoryV2ConceptRowRecord } from "../activation-log-store.js";
 import { loadNowText } from "../now-text.js";
 import type { RouterTurnPair } from "../router.js";
 import type { OracleTurn } from "./oracle.js";

package/src/plugins/defaults/memory/v2/harness/retriever.ts

@@ -10,7 +10,7 @@
  */
 
 import type { AssistantConfig } from "../../../../../config/types.js";
-import type { EverInjectedEntry } from "../../v3/substrate/types.js";
+import type { EverInjectedEntry } from "../../substrate/types.js";
 import type { RouterTurnPair } from "../router.js";
 import type { RetrievalCost } from "./harness-types.js";
 import type { DescentTrace } from "./trace.js";

package/src/plugins/defaults/memory/v2/injection.ts

@@ -25,32 +25,26 @@
 
 import type { AssistantConfig } from "../../../../config/types.js";
 import { getLogger } from "../logging.js";
-import {
-  type MemoryV2ConceptRowRecord,
-  recordMemoryV2ActivationLog,
-} from "../memory-v2-activation-log-store.js";
 import { getWorkspaceDir } from "../paths.js";
 import {
   getCliCommandCapability,
   isCliCommandSlug,
-} from "../v3/substrate/cli-command-store.js";
-import { getEdgeIndex } from "../v3/substrate/edge-index.js";
-import { getPageIndex } from "../v3/substrate/page-index.js";
-import { readPage, renderPageContent } from "../v3/substrate/page-store.js";
-import {
-  getSkillCapability,
-  isSkillSlug,
-} from "../v3/substrate/skill-store.js";
-import type {
-  ActivationState,
-  EverInjectedEntry,
-} from "../v3/substrate/types.js";
+} from "../substrate/cli-command-store.js";
+import { getEdgeIndex } from "../substrate/edge-index.js";
+import { getPageIndex } from "../substrate/page-index.js";
+import { readPage, renderPageContent } from "../substrate/page-store.js";
+import { getSkillCapability, isSkillSlug } from "../substrate/skill-store.js";
+import { spreadActivation } from "../substrate/spread.js";
+import type { ActivationState, EverInjectedEntry } from "../substrate/types.js";
 import {
   computeOwnActivation,
   selectCandidates,
   selectInjections,
-  spreadActivation,
 } from "./activation.js";
+import {
+  type MemoryV2ConceptRowRecord,
+  recordMemoryV2ActivationLog,
+} from "./activation-log-store.js";
 import { hydrate, save } from "./activation-store.js";
 import { recordInjectionEvents } from "./injection-events.js";
 import { type RouterTurnPair, runRouter } from "./router.js";
@@ -253,7 +247,9 @@ export async function injectMemoryV2Block(
   // slugs drop out of consideration next turn.
   const nextStateMap: Record<string, number> = {};
   for (const [slug, value] of finalActivation) {
-    if (value > epsilon) nextStateMap[slug] = value;
+    if (value > epsilon) {
+      nextStateMap[slug] = value;
+    }
   }
 
   // Build the rich per-candidate telemetry rows up front (status assigned
@@ -506,7 +502,9 @@ async function finalizeInjection(args: {
     }
   }
 
-  if (caughtErr !== undefined && !args.bestEffort) throw caughtErr;
+  if (caughtErr !== undefined && !args.bestEffort) {
+    throw caughtErr;
+  }
   return { block, toInject: newlyInjected };
 }
 
@@ -673,7 +671,9 @@ async function injectViaRouter(args: {
   // `source: "carry_over"`. The `status` placeholder is overwritten by
   // `finalizeInjection`.
   const telemetrySlugs = new Set<string>(routerResult.selectedSlugs);
-  for (const entry of priorEverInjected) telemetrySlugs.add(entry.slug);
+  for (const entry of priorEverInjected) {
+    telemetrySlugs.add(entry.slug);
+  }
   const telemetryRows: MemoryV2ConceptRowRecord[] = [...telemetrySlugs].map(
     (slug) => ({
       slug,
@@ -846,9 +846,13 @@ async function renderInjectionBlock(
   const skillSlugs: string[] = [];
   const cliCommandSlugs: string[] = [];
   for (const slug of slugs) {
-    if (isSkillSlug(slug)) skillSlugs.push(slug);
-    else if (isCliCommandSlug(slug)) cliCommandSlugs.push(slug);
-    else conceptSlugs.push(slug);
+    if (isSkillSlug(slug)) {
+      skillSlugs.push(slug);
+    } else if (isCliCommandSlug(slug)) {
+      cliCommandSlugs.push(slug);
+    } else {
+      conceptSlugs.push(slug);
+    }
   }
 
   const settled = await Promise.allSettled(
@@ -886,14 +890,18 @@ async function renderInjectionBlock(
     // empty). Render the full page — frontmatter + body — so retrieval
     // still surfaces the same content the agent saw before this change.
     const content = renderPageContent(page).trim();
-    if (content.length === 0) continue;
+    if (content.length === 0) {
+      continue;
+    }
     sections.push(`# ${path}\n${content}`);
   }
 
   const skillLines: string[] = [];
   for (const slug of skillSlugs) {
     const entry = getSkillCapability(slug);
-    if (!entry) continue;
+    if (!entry) {
+      continue;
+    }
     skillLines.push(`- ${entry.content} → use skill_load to activate`);
   }
   if (skillLines.length > 0) {
@@ -903,7 +911,9 @@ async function renderInjectionBlock(
   const cliCommandLines: string[] = [];
   for (const slug of cliCommandSlugs) {
     const entry = getCliCommandCapability(slug);
-    if (!entry) continue;
+    if (!entry) {
+      continue;
+    }
     cliCommandLines.push(`- \`assistant ${entry.id}\`: ${entry.description}`);
   }
   if (cliCommandLines.length > 0) {

package/src/plugins/defaults/memory/v2/migration.ts

@@ -37,8 +37,8 @@ import {
   listPages,
   slugify,
   writePage,
-} from "../v3/substrate/page-store.js";
-import type { ConceptPage } from "../v3/substrate/types.js";
+} from "../substrate/page-store.js";
+import type { ConceptPage } from "../substrate/types.js";
 
 const log = getLogger("memory-v2-migration");
 

package/src/plugins/defaults/memory/{rerank-local.ts → v2/rerank-local.ts}

@@ -1,11 +1,11 @@
 /** Local cross-encoder rerank backend — drives the rerank-worker subprocess. */
 import { existsSync } from "node:fs";
 
-import type { RerankDtype } from "../../../config/schemas/memory-v2.js";
-import { EmbeddingRuntimeManager } from "../../../persistence/embeddings/embedding-runtime-manager.js";
-import { PromiseGuard, workerMemoryEnv } from "./host-utils.js";
-import { getLogger } from "./logging.js";
-import { getEmbeddingModelsDir } from "./paths.js";
+import type { RerankDtype } from "../../../../config/schemas/memory-v2.js";
+import { EmbeddingRuntimeManager } from "../../../../persistence/embeddings/embedding-runtime-manager.js";
+import { PromiseGuard, workerMemoryEnv } from "../host-utils.js";
+import { getLogger } from "../logging.js";
+import { getEmbeddingModelsDir } from "../paths.js";
 
 const log = getLogger("memory-rerank-local");
 
@@ -52,7 +52,9 @@ export class LocalRerankBackend {
     if (this.disposeRequested) {
       throw new Error("Local rerank backend is shutting down");
     }
-    if (passages.length === 0) return [];
+    if (passages.length === 0) {
+      return [];
+    }
     if (queries.length !== passages.length) {
       throw new Error(
         `Rerank backend got ${queries.length} queries for ${passages.length} passages`,
@@ -107,7 +109,9 @@ export class LocalRerankBackend {
   }
 
   private async ensureInitialized(): Promise<void> {
-    if (this.workerProc) return;
+    if (this.workerProc) {
+      return;
+    }
     await this.initGuard.run(() => this.initialize());
   }
 
@@ -203,9 +207,13 @@ export class LocalRerankBackend {
       try {
         while (true) {
           const { done, value } = await reader.read();
-          if (done) break;
+          if (done) {
+            break;
+          }
           const text = decoder.decode(value, { stream: true }).trim();
-          if (text) log.debug({ workerStderr: text }, "Rerank worker stderr");
+          if (text) {
+            log.debug({ workerStderr: text }, "Rerank worker stderr");
+          }
         }
       } catch {
         /* expected on shutdown */
@@ -214,7 +222,9 @@ export class LocalRerankBackend {
   }
 
   private startStdoutReader(): void {
-    if (this.stdoutReaderActive || !this.workerProc) return;
+    if (this.stdoutReaderActive || !this.workerProc) {
+      return;
+    }
     this.stdoutReaderActive = true;
 
     const proc = this.workerProc;
@@ -225,7 +235,9 @@ export class LocalRerankBackend {
       try {
         while (true) {
           const { done, value } = await reader.read();
-          if (done) break;
+          if (done) {
+            break;
+          }
           this.stdoutBuffer += decoder.decode(value, { stream: true });
           this.processStdoutBuffer();
         }
@@ -253,7 +265,9 @@ export class LocalRerankBackend {
     while ((idx = this.stdoutBuffer.indexOf("\n")) !== -1) {
       const line = this.stdoutBuffer.slice(0, idx);
       this.stdoutBuffer = this.stdoutBuffer.slice(idx + 1);
-      if (!line.trim()) continue;
+      if (!line.trim()) {
+        continue;
+      }
 
       let msg: WorkerResponse;
       try {
@@ -321,10 +335,18 @@ export class LocalRerankBackend {
   }
 
   private disposeIfIdle(): void {
-    if (!this.disposeRequested) return;
-    if (this.activeRequests > 0) return;
-    if (this.pendingRequests.size > 0) return;
-    if (this.readyResolve || this.readyReject) return;
+    if (!this.disposeRequested) {
+      return;
+    }
+    if (this.activeRequests > 0) {
+      return;
+    }
+    if (this.pendingRequests.size > 0) {
+      return;
+    }
+    if (this.readyResolve || this.readyReject) {
+      return;
+    }
 
     const proc = this.workerProc;
     this.workerProc = null;
@@ -332,7 +354,9 @@ export class LocalRerankBackend {
     this.stdoutBuffer = "";
     this.initGuard.reset();
 
-    if (!proc) return;
+    if (!proc) {
+      return;
+    }
 
     try {
       proc.kill();
@@ -350,7 +374,9 @@ export function getOrCreateRerankBackend(
   model: string,
   dtype: RerankDtype,
 ): LocalRerankBackend {
-  if (_backend?.model === model && _backend.dtype === dtype) return _backend;
+  if (_backend?.model === model && _backend.dtype === dtype) {
+    return _backend;
+  }
   if (_backend) {
     try {
       _backend.dispose();