@vellumai/assistant 0.11.0 → 0.11.1-staging.2

package/src/plugins/defaults/memory/v3/core-set.ts

@@ -49,9 +49,13 @@ export function loadCoreSet(workspaceDir: string): Slug[] {
   const slugs: Slug[] = [];
   for (const line of raw.split("\n")) {
     const match = LIST_LINE.exec(line.trim());
-    if (!match) continue;
+    if (!match) {
+      continue;
+    }
     const slug = (match[1] ?? match[2] ?? "").trim();
-    if (!SLUG_SHAPE.test(slug) || seen.has(slug)) continue;
+    if (!SLUG_SHAPE.test(slug) || seen.has(slug)) {
+      continue;
+    }
     seen.add(slug);
     slugs.push(slug);
   }

package/src/plugins/defaults/memory/v3/dense.ts

@@ -67,7 +67,9 @@ export async function denseLaneScored(
   query: string,
   k: number,
 ): Promise<DenseHitScored[]> {
-  if (k <= 0) return [];
+  if (k <= 0) {
+    return [];
+  }
 
   let points: Array<{ payload?: unknown; score?: number }>;
   try {
@@ -82,7 +84,9 @@ export async function denseLaneScored(
 
     const { vectors } = await embedWithBackend(config, [query]);
     const vector = vectors[0];
-    if (!vector || vector.length === 0) return [];
+    if (!vector || vector.length === 0) {
+      return [];
+    }
 
     const result = await getSectionDenseClient().query(SECTION_COLLECTION, {
       query: vector,
@@ -106,11 +110,17 @@ export async function denseLaneScored(
       | undefined;
     const article = payload?.article;
     const ordinal = payload?.ordinal;
-    if (typeof article !== "string" || typeof ordinal !== "number") continue;
-    if (seen.has(article)) continue;
+    if (typeof article !== "string" || typeof ordinal !== "number") {
+      continue;
+    }
+    if (seen.has(article)) {
+      continue;
+    }
     seen.add(article);
     hits.push({ article, section: ordinal, score: point.score ?? 0 });
-    if (hits.length >= k) break;
+    if (hits.length >= k) {
+      break;
+    }
   }
 
   return hits;

package/src/plugins/defaults/memory/v3/entity-lane.ts

@@ -46,9 +46,13 @@ export function buildEntityIndex(
   const byToken: EntityIndex = new Map();
   for (let doc = 0; doc < index.sections.length; doc++) {
     const title = index.sections[doc]!.title;
-    if (title.length === 0) continue;
+    if (title.length === 0) {
+      continue;
+    }
     for (const token of new Set(tokenize(title))) {
-      if (!isDistinctive(token)) continue;
+      if (!isDistinctive(token)) {
+        continue;
+      }
       let docs = byToken.get(token);
       if (!docs) {
         docs = [];
@@ -77,7 +81,9 @@ export function entityLane(
   message: string,
   cap: number,
 ): { article: Slug; section: number }[] {
-  if (cap <= 0) return [];
+  if (cap <= 0) {
+    return [];
+  }
 
   // Per heading section hit by ≥1 message token, count how many DISTINCT message
   // tokens its heading contains (the entity index maps token → sections whose

package/src/plugins/defaults/memory/v3/ever-injected-store.ts

@@ -59,7 +59,9 @@ export function getInjected(
   conversationId: string,
 ): Map<string, EverInjectedEntry> {
   const mdb = memoryDbOrNull("getInjected");
-  if (!mdb) return new Map();
+  if (!mdb) {
+    return new Map();
+  }
   const rows = mdb
     .select({
       slug: memoryV3EverInjected.slug,
@@ -78,7 +80,9 @@ export function getInjected(
 /** The injection dedup set: slugs whose cards are currently resident. */
 export function getActiveSlugs(conversationId: string): Set<string> {
   const mdb = memoryDbOrNull("getActiveSlugs");
-  if (!mdb) return new Set();
+  if (!mdb) {
+    return new Set();
+  }
   const rows = mdb
     .select({ slug: memoryV3EverInjected.slug })
     .from(memoryV3EverInjected)
@@ -109,7 +113,9 @@ export function getActiveEntries(
   conversationId: string,
 ): ActiveInjectedEntry[] {
   const mdb = memoryDbOrNull("getActiveEntries");
-  if (!mdb) return [];
+  if (!mdb) {
+    return [];
+  }
   return mdb
     .select({
       slug: memoryV3EverInjected.slug,
@@ -133,7 +139,9 @@ export function getActiveEntries(
  */
 export function getPrunedSlugs(conversationId: string): Set<string> {
   const mdb = memoryDbOrNull("getPrunedSlugs");
-  if (!mdb) return new Set();
+  if (!mdb) {
+    return new Set();
+  }
   const rows = mdb
     .select({ slug: memoryV3EverInjected.slug })
     .from(memoryV3EverInjected)
@@ -157,13 +165,17 @@ export function recordInjected(
   entries: Array<{ slug: string; bytes: number }>,
   at: number = Date.now(),
 ): void {
-  if (entries.length === 0) return;
+  if (entries.length === 0) {
+    return;
+  }
   // Best-effort — a derived injection-accounting write must never abort the
   // agent turn, so a degraded memory connection or a failed statement only
   // logs a warning.
   try {
     const mdb = memoryDbOrNull("recordInjected");
-    if (!mdb) return;
+    if (!mdb) {
+      return;
+    }
     for (const entry of entries) {
       mdb
         .insert(memoryV3EverInjected)
@@ -197,10 +209,14 @@ export function markPruned(
   slugs: string[],
   at: number,
 ): void {
-  if (slugs.length === 0) return;
+  if (slugs.length === 0) {
+    return;
+  }
   try {
     const mdb = memoryDbOrNull("markPruned");
-    if (!mdb) return;
+    if (!mdb) {
+      return;
+    }
     mdb
       .update(memoryV3EverInjected)
       .set({ prunedAt: at })
@@ -223,7 +239,9 @@ export function markPruned(
 export function clearConversation(conversationId: string): void {
   try {
     const mdb = memoryDbOrNull("clearConversation");
-    if (!mdb) return;
+    if (!mdb) {
+      return;
+    }
     mdb
       .delete(memoryV3EverInjected)
       .where(eq(memoryV3EverInjected.conversationId, conversationId))
@@ -239,7 +257,9 @@ export function clearConversation(conversationId: string): void {
 /** Total bytes of resident (non-pruned) cards — the prune-valve input. */
 export function residentBytes(conversationId: string): number {
   const mdb = memoryDbOrNull("residentBytes");
-  if (!mdb) return 0;
+  if (!mdb) {
+    return 0;
+  }
   const row = mdb
     .select({
       total: sql<number>`COALESCE(SUM(${memoryV3EverInjected.bytes}), 0)`,
@@ -270,7 +290,9 @@ export function forkEverInjected(
 ): void {
   try {
     const mdb = memoryDbOrNull("forkEverInjected");
-    if (!mdb) return;
+    if (!mdb) {
+      return;
+    }
     const parentRows = mdb
       .select({
         slug: memoryV3EverInjected.slug,
@@ -335,10 +357,14 @@ export function seedEverInjectedFromSlugs(
   slugs: string[],
   at: number,
 ): void {
-  if (slugs.length === 0) return;
+  if (slugs.length === 0) {
+    return;
+  }
   try {
     const mdb = memoryDbOrNull("seedEverInjectedFromSlugs");
-    if (!mdb) return;
+    if (!mdb) {
+      return;
+    }
     const prunedRows = mdb
       .select({
         slug: memoryV3EverInjected.slug,

package/src/plugins/defaults/memory/v3/fresh-set.ts

@@ -1,13 +1,16 @@
 /**
  * Recency fresh-set lane.
  *
- * Returns the top-K page slugs by most-recent on-disk modification
- * (`PageIndexEntry.modifiedAt`). The fresh set keeps *just-written* pages in
- * the candidate pool during the window before the other lanes can reach them:
- * a page consolidated minutes ago has no selection history (so frecency can't
- * rank it into the hot set) and a "what happened today?"-shaped message gives
- * the finder lanes nothing lexical to match it on. Recency is exactly the
- * signal those lanes are missing, so it gets its own lane.
+ * Returns the top-K page slugs by effective recency
+ * (`PageIndexEntry.freshAt`: the parsed `origin_date` frontmatter when
+ * present, else the file mtime), so origin-dated imports sort by their
+ * original chronology instead of their import time. The fresh set keeps
+ * *just-written* pages in the candidate pool during the window before the
+ * other lanes can reach them: a page consolidated minutes ago has no
+ * selection history (so frecency can't rank it into the hot set) and a
+ * "what happened today?"-shaped message gives the finder lanes nothing
+ * lexical to match it on. Recency is exactly the signal those lanes are
+ * missing, so it gets its own lane.
  *
  * Like core and hot, the fresh set is a stable-prefix lane: it is computed at
  * lane init and recomputed only on lane invalidation (the consolidation
@@ -19,7 +22,7 @@
  * Slugs in `excludeSlugs` (core + hot members) are dropped before the K cut —
  * those pages already sit in the stable prefix, so re-listing them would only
  * spend fresh slots on duplicates. Synthetic capability entries carry
- * `modifiedAt: 0` and are skipped: they have no on-disk write to be fresh by.
+ * `freshAt: null` and are skipped: they have no on-disk write to be fresh by.
  */
 
 import type { Slug } from "./types.js";
@@ -27,8 +30,10 @@ import type { Slug } from "./types.js";
 /** The slice of a page-index entry the fresh lane ranks on. */
 export interface FreshSetEntry {
   slug: Slug;
-  /** File mtime in epoch ms; `0` for synthetic entries (skills, CLI commands). */
-  modifiedAt: number;
+  /** Effective recency in epoch ms (origin date when declared, else file
+   *  mtime); pre-epoch origin dates are valid zero or negative values.
+   *  `null` for synthetic entries (skills, CLI commands). */
+  freshAt: number | null;
 }
 
 export interface FreshSetOptions {
@@ -40,20 +45,27 @@ export interface FreshSetOptions {
 }
 
 /**
- * Compute the top-`k` fresh slugs by file modification time, newest first.
+ * Compute the top-`k` fresh slugs by effective recency, newest first.
  *
- * Deterministic for fixed inputs: ties break `modifiedAt` desc, then slug asc.
+ * Deterministic for fixed inputs: ties break `freshAt` desc, then slug asc.
  */
 export function computeFreshSet(
   entries: readonly FreshSetEntry[],
   opts: FreshSetOptions,
 ): Slug[] {
   const { k, excludeSlugs } = opts;
-  if (k <= 0) return [];
+  if (k <= 0) {
+    return [];
+  }
 
   return entries
-    .filter((entry) => entry.modifiedAt > 0 && !excludeSlugs.has(entry.slug))
-    .sort((a, b) => b.modifiedAt - a.modifiedAt || (a.slug < b.slug ? -1 : 1))
+    .filter(
+      (entry): entry is FreshSetEntry & { freshAt: number } =>
+        entry.freshAt !== null &&
+        Number.isFinite(entry.freshAt) &&
+        !excludeSlugs.has(entry.slug),
+    )
+    .sort((a, b) => b.freshAt - a.freshAt || (a.slug < b.slug ? -1 : 1))
     .slice(0, k)
     .map((entry) => entry.slug);
 }

package/src/plugins/defaults/memory/v3/hot-set.ts

@@ -51,7 +51,9 @@ interface SelectionAgeRow {
  */
 export function computeHotSet(opts: HotSetOptions): HotSetEntry[] {
   const { k, halfLifeMs, now, excludeSlugs } = opts;
-  if (k <= 0) return [];
+  if (k <= 0) {
+    return [];
+  }
 
   const raw = memorySqliteOrNull("computeHotSet");
   if (!raw) {
@@ -68,7 +70,9 @@ export function computeHotSet(opts: HotSetOptions): HotSetEntry[] {
 
   const scores = new Map<Slug, number>();
   for (const row of rows) {
-    if (excludeSlugs.has(row.slug)) continue;
+    if (excludeSlugs.has(row.slug)) {
+      continue;
+    }
     // Clamp future-dated rows (clock skew) to "now" rather than letting them
     // score above 1 per selection.
     const age = Math.max(0, now - row.created_at);

package/src/plugins/defaults/memory/v3/injector.ts

@@ -116,7 +116,9 @@ function lruSet<V>(map: Map<string, V>, key: string, value: V): void {
     map.delete(key);
   } else if (map.size >= MAX_TRACKED_CONVERSATIONS) {
     const oldest = map.keys().next().value;
-    if (oldest !== undefined) map.delete(oldest);
+    if (oldest !== undefined) {
+      map.delete(oldest);
+    }
   }
   map.set(key, value);
 }
@@ -126,7 +128,9 @@ function queueMemoryV3ConversationNotice(
   ctx: TurnContext,
   live: boolean,
 ): void {
-  if (!live) return;
+  if (!live) {
+    return;
+  }
   const notice: PendingConversationNotice = err.conversationNotice ?? {
     source: "memory_v3",
     code: "UNKNOWN",
@@ -165,7 +169,9 @@ function observeTurnOnce(
   turnIndex: number,
 ): Promise<OrchestrateResult | null> {
   const cached = observedTurns.get(conversationId);
-  if (cached && cached.turnIndex === turnIndex) return cached.result;
+  if (cached && cached.turnIndex === turnIndex) {
+    return cached.result;
+  }
   const result = observeTurn(conversationId, turnIndex);
   lruSet(observedTurns, conversationId, { turnIndex, result });
   return result;
@@ -195,14 +201,22 @@ function computeSpotlightEntries(
   const selected = new Set<Slug>(result.selections.map((s) => s.slug));
   const entries: SpotlightEntry[] = [];
   for (const candidate of result.lanes.finder) {
-    if (entries.length >= n) break;
-    if (!selected.has(candidate.slug)) continue;
+    if (entries.length >= n) {
+      break;
+    }
+    if (!selected.has(candidate.slug)) {
+      continue;
+    }
     // Capability slugs never spotlight: their card already carries the whole
     // injection form, and their index "sections" are slices of the full-help
     // body the injection layer deliberately keeps out of context.
-    if (isCapabilitySlug(candidate.slug)) continue;
+    if (isCapabilitySlug(candidate.slug)) {
+      continue;
+    }
     const section = result.matchedSections.get(candidate.slug);
-    if (!section) continue;
+    if (!section) {
+      continue;
+    }
     entries.push({
       slug: candidate.slug,
       title: section.title,
@@ -236,7 +250,9 @@ function updateSpotlightWindow(
   for (const turn of [{ turnIndex, entries }, ...prior.reverse()]) {
     for (const entry of turn.entries) {
       const key = `${entry.slug}§${entry.title}`;
-      if (seen.has(key)) continue;
+      if (seen.has(key)) {
+        continue;
+      }
       seen.add(key);
       window.push(entry);
     }
@@ -264,8 +280,12 @@ export const memoryV3Injector: Injector = {
       return null;
     }
     const live = isMemoryV3Live(config);
-    if (!live) return null;
-    if (!isPersonalMemoryAllowed(ctx.trust)) return null;
+    if (!live) {
+      return null;
+    }
+    if (!isPersonalMemoryAllowed(ctx.trust)) {
+      return null;
+    }
 
     let observed: OrchestrateResult | null;
     try {
@@ -288,7 +308,9 @@ export const memoryV3Injector: Injector = {
     // hook skipped v2 retrieval under live, so a turn with nothing selected
     // simply gets no v3 `<memory>` block (prior turns' frozen cards still ride
     // history).
-    if (!observed || observed.selections.length === 0) return null;
+    if (!observed || observed.selections.length === 0) {
+      return null;
+    }
     // `const` so the non-null narrowing survives capture in the `commit`
     // closure below (a `let` would re-widen to `OrchestrateResult | null`).
     const result = observed;
@@ -305,14 +327,18 @@ export const memoryV3Injector: Injector = {
       const cards: Array<{ slug: Slug; card: string }> = [];
       for (const slug of netNew) {
         const card = await renderV3CardContent(slug);
-        if (card.trim().length > 0) cards.push({ slug, card });
+        if (card.trim().length > 0) {
+          cards.push({ slug, card });
+        }
       }
       // Every net-new card rendered empty: return null rather than an
       // empty-text block. Under live there is no v2 block, so the turn simply
       // gets no new memory. Distinct from the all-repeat case (empty `netNew`),
       // where the empty block correctly keeps v2 suppressed because the cards
       // already ride history.
-      if (netNew.length > 0 && cards.length === 0) return null;
+      if (netNew.length > 0 && cards.length === 0) {
+        return null;
+      }
       const entries = cards.map(({ slug, card }) => ({
         slug,
         // Capability cards (skills / CLI commands) render with their own
@@ -380,12 +406,18 @@ export const memoryV3SpotlightInjector: Injector = {
     }
     // The spotlight rides the live `<memory>` layer; with `memory.v3.live` off
     // it produces nothing and keeps no ring state.
-    if (!isMemoryV3Live(config)) return null;
-    if (!isPersonalMemoryAllowed(ctx.trust)) return null;
+    if (!isMemoryV3Live(config)) {
+      return null;
+    }
+    if (!isPersonalMemoryAllowed(ctx.trust)) {
+      return null;
+    }
 
     try {
       const result = await observeTurnOnce(ctx.conversationId, ctx.turnIndex);
-      if (!result || result.selections.length === 0) return null;
+      if (!result || result.selections.length === 0) {
+        return null;
+      }
 
       const { n, windowTurns } = config.memory.v3.spotlight;
       const current = computeSpotlightEntries(result, n);
@@ -395,7 +427,9 @@ export const memoryV3SpotlightInjector: Injector = {
         current,
         windowTurns,
       );
-      if (window.length === 0) return null;
+      if (window.length === 0) {
+        return null;
+      }
 
       return {
         id: MEMORY_V3_SPOTLIGHT_BLOCK_ID,

package/src/plugins/defaults/memory/v3/learned-edges.ts

@@ -90,7 +90,9 @@ export function computeLearnedEdgeGraph(opts: LearnedEdgesOptions): EdgeGraph {
     hubs: new Set(),
     slugs: opts.knownSlugs,
   };
-  if (maxPerPage <= 0) return empty;
+  if (maxPerPage <= 0) {
+    return empty;
+  }
 
   const raw = memorySqliteOrNull("computeLearnedEdgeGraph");
   if (!raw) {
@@ -105,12 +107,16 @@ export function computeLearnedEdgeGraph(opts: LearnedEdgesOptions): EdgeGraph {
     `,
     )
     .all(now - windowMs) as SelectionRow[];
-  if (rows.length === 0) return empty;
+  if (rows.length === 0) {
+    return empty;
+  }
 
   // Group into selector calls; one decayed weight per call.
   const calls = new Map<string, { weight: number; slugs: Set<Slug> }>();
   for (const row of rows) {
-    if (!opts.knownSlugs.has(row.slug)) continue;
+    if (!opts.knownSlugs.has(row.slug)) {
+      continue;
+    }
     const key = `${row.conversation_id}|${row.created_at}`;
     let call = calls.get(key);
     if (!call) {
@@ -129,7 +135,9 @@ export function computeLearnedEdgeGraph(opts: LearnedEdgesOptions): EdgeGraph {
   for (const { weight, slugs } of calls.values()) {
     total += weight;
     const arr = [...slugs];
-    for (const slug of arr) uni.set(slug, (uni.get(slug) ?? 0) + weight);
+    for (const slug of arr) {
+      uni.set(slug, (uni.get(slug) ?? 0) + weight);
+    }
     for (let i = 0; i < arr.length; i++) {
       for (let j = i + 1; j < arr.length; j++) {
         const key =
@@ -138,7 +146,9 @@ export function computeLearnedEdgeGraph(opts: LearnedEdgesOptions): EdgeGraph {
       }
     }
   }
-  if (total <= 0) return empty;
+  if (total <= 0) {
+    return empty;
+  }
 
   // Score pairs and collect each endpoint's qualifying neighbors.
   const neighbors = new Map<Slug, Array<{ peer: Slug; npmi: number }>>();
@@ -151,7 +161,9 @@ export function computeLearnedEdgeGraph(opts: LearnedEdgesOptions): EdgeGraph {
     list.push({ peer, npmi });
   };
   for (const [key, mass] of pair) {
-    if (mass < minCount) continue;
+    if (mass < minCount) {
+      continue;
+    }
     const [a, b] = key.split("\t") as [Slug, Slug];
     const pab = mass / total;
     const pa = uni.get(a)! / total;
@@ -173,7 +185,9 @@ export function computeLearnedEdgeGraph(opts: LearnedEdgesOptions): EdgeGraph {
   for (const [slug, list] of neighbors) {
     list.sort((x, y) => y.npmi - x.npmi || (x.peer < y.peer ? -1 : 1));
     const out = new Map<Slug, string | undefined>();
-    for (const { peer } of list.slice(0, maxPerPage)) out.set(peer, undefined);
+    for (const { peer } of list.slice(0, maxPerPage)) {
+      out.set(peer, undefined);
+    }
     adjacency.set(slug, out);
   }
 

package/src/plugins/defaults/memory/v3/llm-retry.ts

@@ -22,7 +22,9 @@ export async function retryForResult<T>(
   for (let i = 0; i < maxAttempts; i++) {
     try {
       const result = await attempt();
-      if (result !== null) return result;
+      if (result !== null) {
+        return result;
+      }
     } catch {
       // Treat a throw like an unusable result and retry. The provider layer has
       // already backed off transient errors, so there is nothing to wait for.

package/src/plugins/defaults/memory/v3/orchestrate.ts

@@ -444,7 +444,9 @@ export async function orchestrate(
     if (section && !matchedSections.has(slug)) {
       matchedSections.set(slug, section);
     }
-    if (finderSeen.has(slug)) return;
+    if (finderSeen.has(slug)) {
+      return;
+    }
     finderSeen.add(slug);
     finder.push({
       slug,
@@ -496,7 +498,9 @@ export async function orchestrate(
     addFinder(hit.article, sections[hit.section], undefined, "reply");
   }
   for (const hit of replyDensed) {
-    if (!deps.sectionIndex.byArticle.has(hit.article)) continue;
+    if (!deps.sectionIndex.byArticle.has(hit.article)) {
+      continue;
+    }
     addFinder(
       hit.article,
       sectionByOrdinal(deps.sectionIndex, hit.article, hit.section),
@@ -577,7 +581,9 @@ export async function orchestrate(
       if (section) {
         matchedSections.set(hit.article, section);
         const existing = finder.find((c) => c.slug === hit.article);
-        if (existing) existing.descriptor = section.text;
+        if (existing) {
+          existing.descriptor = section.text;
+        }
       }
       addFinder(hit.article, section, undefined, "entity");
     }
@@ -882,10 +888,14 @@ export function sectionByOrdinal(
   ordinal: number,
 ): Section | undefined {
   const indices = index.byArticle.get(article);
-  if (!indices) return undefined;
+  if (!indices) {
+    return undefined;
+  }
   for (const i of indices) {
     const section = index.sections[i];
-    if (section && section.ordinal === ordinal) return section;
+    if (section && section.ordinal === ordinal) {
+      return section;
+    }
   }
   return undefined;
 }

package/src/plugins/defaults/memory/v3/pool-select.test.ts

@@ -33,7 +33,9 @@ let sendMessageImpl: (() => Promise<ProviderResponse>) | null = null;
 const mockProvider = {
   name: "mock-memory-v3-selector",
   async sendMessage(): Promise<ProviderResponse> {
-    if (!sendMessageImpl) throw new Error("sendMessageImpl not configured");
+    if (!sendMessageImpl) {
+      throw new Error("sendMessageImpl not configured");
+    }
     return sendMessageImpl();
   },
 } as unknown as Provider;

package/src/plugins/defaults/memory/v3/pool-select.ts

@@ -104,7 +104,9 @@ function providerBillingNoticeFromError(
   const classified = classifyConversationError(error, {
     phase: "agent_loop",
   });
-  if (classified.code !== "PROVIDER_BILLING") return undefined;
+  if (classified.code !== "PROVIDER_BILLING") {
+    return undefined;
+  }
   return {
     source: "memory_v3",
     code: classified.code,
@@ -255,7 +257,9 @@ function renderSnippet(descriptor: string): string {
 }
 
 function readStringField(value: unknown, key: string): string | undefined {
-  if (value === null || typeof value !== "object") return undefined;
+  if (value === null || typeof value !== "object") {
+    return undefined;
+  }
   const field = (value as Record<string, unknown>)[key];
   return typeof field === "string" && field.length > 0 ? field : undefined;
 }
@@ -399,7 +403,9 @@ export async function selectPool(
     ...pool.stable.map((c) => c.slug),
     ...pool.finder.map((c) => c.slug),
   ];
-  if (ordered.length === 0) return { pages: [], keptAll: false };
+  if (ordered.length === 0) {
+    return { pages: [], keptAll: false };
+  }
 
   const keepAll = (): SelectedPage[] => selectAllPoolCandidates(pool);
 
@@ -582,7 +588,9 @@ export async function selectPool(
   }
 
   // Omitted `ids` is the recall-safe "keep all candidates" signal.
-  if (parsed.ids === undefined) return { pages: keepAll(), keptAll: true };
+  if (parsed.ids === undefined) {
+    return { pages: keepAll(), keptAll: true };
+  }
 
   const pinned = new Set(parsed.pinned_ids ?? []);
 
@@ -590,7 +598,9 @@ export async function selectPool(
   // IDs without throwing, then dedupe by slug (pinned flags ORed).
   const selected: Array<{ slug: Slug; pinned: boolean }> = [];
   for (const id of parsed.ids) {
-    if (id < 1 || id > ordered.length) continue;
+    if (id < 1 || id > ordered.length) {
+      continue;
+    }
     selected.push({ slug: ordered[id - 1]!, pinned: pinned.has(id) });
   }
   return { pages: dedupeBySlug(selected), keptAll: false };