@vellumai/assistant 0.8.3 → 0.8.5

package/src/memory/v2/consolidation-job.ts

@@ -244,6 +244,20 @@ function readBufferContent(bufferPath: string): string {
   }
 }
 
+/**
+ * Count non-empty lines in `memory/buffer.md`. Used by the scheduler to
+ * implement the size-based consolidation trigger. Missing file → 0.
+ *
+ * Each entry is one line (`- [Mon D, h:mm AM/PM] …\n`), so non-empty-line
+ * count == entry count for a well-formed buffer; blank lines and trailing
+ * newlines don't inflate the count.
+ */
+export function countBufferLines(bufferPath: string): number {
+  const content = readBufferContent(bufferPath);
+  if (content.length === 0) return 0;
+  return content.split("\n").filter((line) => line.trim().length > 0).length;
+}
+
 /**
  * Atomically create the lock file with `wx` (O_CREAT | O_EXCL) flags. Returns
  * `null` on success, or the current holder string (file contents, typically

package/src/memory/v2/harness/compare.ts

@@ -0,0 +1,57 @@
+/**
+ * Run the comparison harness over a sample of historical turns.
+ *
+ * Ties the harness pieces together: pull oracle turns from telemetry, run each
+ * retriever over each turn's reconstructed inputs, score against the logged
+ * ground truth. Kept separate from the route handler so it can be unit-tested
+ * with a stub retriever and a fixture DB — no live router / LLM.
+ */
+
+import type { AssistantConfig } from "../../../config/types.js";
+import type { DrizzleDb } from "../../db-connection.js";
+import { extractOracleTurns } from "./oracle.js";
+import { reconstructInput } from "./replay-input.js";
+import type { Retriever } from "./retriever.js";
+import { type ComparisonReport, runComparison } from "./runner.js";
+
+export interface RunComparisonOverHistoryParams {
+  db: DrizzleDb;
+  workspaceDir: string;
+  config: AssistantConfig;
+  retrievers: readonly Retriever[];
+  ks: number[];
+  limit?: number;
+  strategy?: "recent" | "random";
+  conversationIds?: string[];
+  includeNotInjected?: boolean;
+  pageExists?: (slug: string) => boolean;
+  signal?: AbortSignal;
+}
+
+export async function runComparisonOverHistory(
+  params: RunComparisonOverHistoryParams,
+): Promise<ComparisonReport> {
+  const { db, workspaceDir, config } = params;
+
+  const oracleTurns = extractOracleTurns(db, {
+    ...(params.limit !== undefined ? { limit: params.limit } : {}),
+    ...(params.strategy !== undefined ? { strategy: params.strategy } : {}),
+    ...(params.conversationIds !== undefined
+      ? { conversationIds: params.conversationIds }
+      : {}),
+    ...(params.includeNotInjected !== undefined
+      ? { includeNotInjected: params.includeNotInjected }
+      : {}),
+    ...(params.pageExists !== undefined
+      ? { pageExists: params.pageExists }
+      : {}),
+  });
+
+  return runComparison({
+    retrievers: params.retrievers,
+    oracleTurns,
+    reconstruct: (turn) => reconstructInput(db, turn, config, workspaceDir),
+    ks: params.ks,
+    ...(params.signal !== undefined ? { signal: params.signal } : {}),
+  });
+}

package/src/memory/v2/harness/metrics.ts

@@ -0,0 +1,124 @@
+/**
+ * Recall@k and per-lane diff for the comparison harness.
+ *
+ * Ground truth is the current router's logged selections (see `oracle.ts`). A
+ * retriever's "extras" (selected, not in ground truth) are reported as a
+ * *diff*, not an error — a better retriever may legitimately surface pages the
+ * router missed. recall@k is the primary signal.
+ */
+
+import type { RetrievalOutput } from "./retriever.js";
+
+export interface TurnEval {
+  groundTruth: string[];
+  selected: string[];
+  /** Ground-truth slugs the retriever selected (anywhere in its output). */
+  hits: string[];
+  /** Ground-truth slugs the retriever missed entirely. */
+  misses: string[];
+  /** Selected slugs not in ground truth — diff, not error. */
+  extras: string[];
+  /** recall@k for each requested k. */
+  recallAtK: Record<number, number>;
+  /** Counts of hits grouped by the retriever's source/lane labels. */
+  hitsByLane: Record<string, number>;
+  costUsd?: number;
+  failureReason: string | null;
+}
+
+export interface AggregateEval {
+  turns: number;
+  meanRecallAtK: Record<number, number>;
+  failureRate: number;
+  meanCostUsd?: number;
+}
+
+/**
+ * recall@k = |topK(selected) ∩ G| / |G|. An empty ground-truth set is defined
+ * as recall 1 (nothing to recall — vacuously complete).
+ */
+export function recallAtK(
+  selected: readonly string[],
+  groundTruth: ReadonlySet<string>,
+  k: number,
+): number {
+  if (groundTruth.size === 0) return 1;
+  let hit = 0;
+  for (const slug of selected.slice(0, k)) {
+    if (groundTruth.has(slug)) hit++;
+  }
+  return hit / groundTruth.size;
+}
+
+export function evalTurn(
+  output: RetrievalOutput,
+  groundTruth: readonly string[],
+  ks: readonly number[],
+): TurnEval {
+  const gtList = Array.from(new Set(groundTruth));
+  const gtSet = new Set(gtList);
+  const selectedSet = new Set(output.selectedSlugs);
+
+  const hits: string[] = [];
+  const misses: string[] = [];
+  for (const slug of gtList) {
+    (selectedSet.has(slug) ? hits : misses).push(slug);
+  }
+  const extras = output.selectedSlugs.filter((s) => !gtSet.has(s));
+
+  const recall: Record<number, number> = {};
+  for (const k of ks) {
+    recall[k] = recallAtK(output.selectedSlugs, gtSet, k);
+  }
+
+  const hitsByLane: Record<string, number> = {};
+  for (const slug of hits) {
+    const lane = output.sourceBySlug.get(slug) ?? "unknown";
+    hitsByLane[lane] = (hitsByLane[lane] ?? 0) + 1;
+  }
+
+  return {
+    groundTruth: gtList,
+    selected: output.selectedSlugs,
+    hits,
+    misses,
+    extras,
+    recallAtK: recall,
+    hitsByLane,
+    ...(output.cost?.usd !== undefined ? { costUsd: output.cost.usd } : {}),
+    failureReason: output.failureReason ?? null,
+  };
+}
+
+export function aggregate(
+  perTurn: readonly TurnEval[],
+  ks: readonly number[],
+): AggregateEval {
+  const turns = perTurn.length;
+
+  const meanRecallAtK: Record<number, number> = {};
+  for (const k of ks) {
+    if (turns === 0) {
+      meanRecallAtK[k] = 0;
+      continue;
+    }
+    let sum = 0;
+    for (const t of perTurn) sum += t.recallAtK[k] ?? 0;
+    meanRecallAtK[k] = sum / turns;
+  }
+
+  const failures = perTurn.filter((t) => t.failureReason != null).length;
+  const costed = perTurn.filter((t) => t.costUsd !== undefined);
+
+  return {
+    turns,
+    meanRecallAtK,
+    failureRate: turns === 0 ? 0 : failures / turns,
+    ...(costed.length > 0
+      ? {
+          meanCostUsd:
+            costed.reduce((s, t) => s + (t.costUsd ?? 0), 0) / costed.length,
+        }
+      : {}),
+  };
+}

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

@@ -0,0 +1,145 @@
+/**
+ * Oracle extraction — the current router's logged selections as silver-standard
+ * ground truth.
+ *
+ * Source: `memory_v2_activation_logs` rows with `mode = 'router'`. Each row's
+ * `messageId` is backfilled to the turn's assistant message (see
+ * `backfillMemoryV2ActivationMessageId`), so we join `messageId → messages.id`
+ * to anchor the turn — robust, no fragile turn-counting. Rows whose messageId
+ * is null (the in-flight turn) or no longer resolves are skipped.
+ *
+ * Ground truth G(turn) = selected slugs with status ∈ {injected, in_context}
+ * (what actually reached the model), optionally + not_injected, and — when a
+ * `pageExists` predicate is supplied — only slugs whose page still exists
+ * (neither retriever can find a nonexistent page). page_missing / corrupt are
+ * always excluded.
+ */
+
+import { and, desc, eq, inArray, isNotNull, sql } from "drizzle-orm";
+
+import type { DrizzleDb } from "../../db-connection.js";
+import type {
+  MemoryV2ConceptRowRecord,
+  MemoryV2ConfigSnapshot,
+} from "../../memory-v2-activation-log-store.js";
+import { memoryV2ActivationLogs, messages } from "../../schema.js";
+
+export interface OracleTurn {
+  conversationId: string;
+  turn: number;
+  /** Backfilled assistant-message id for this turn — the reconstruction anchor. */
+  anchorMessageId: string;
+  /** `created_at` of the anchor message; reconstruction cuts strictly before it. */
+  anchorCreatedAt: number;
+  /** Slugs the router's judgment put in front of the model (the recall target). */
+  groundTruthSlugs: string[];
+  loggedConfig: MemoryV2ConfigSnapshot;
+  createdAt: number;
+}
+
+export interface ExtractOracleOptions {
+  /** Max log rows to scan (default 50). Some are skipped, so result ≤ limit. */
+  limit?: number;
+  strategy?: "recent" | "random";
+  conversationIds?: string[];
+  /** Include status "not_injected" (selected but cut by the cap) in G. Default false. */
+  includeNotInjected?: boolean;
+  /**
+   * Page-existence predicate, typically backed by `getPageIndex().bySlug`.
+   * When provided, ground-truth slugs whose page no longer exists are dropped.
+   * Omit in unit tests.
+   */
+  pageExists?: (slug: string) => boolean;
+}
+
+export function extractOracleTurns(
+  db: DrizzleDb,
+  options: ExtractOracleOptions = {},
+): OracleTurn[] {
+  const {
+    limit = 50,
+    strategy = "recent",
+    conversationIds,
+    includeNotInjected = false,
+    pageExists,
+  } = options;
+
+  const allowedStatuses = new Set<string>(["injected", "in_context"]);
+  if (includeNotInjected) allowedStatuses.add("not_injected");
+
+  const filters = [
+    eq(memoryV2ActivationLogs.mode, "router"),
+    isNotNull(memoryV2ActivationLogs.messageId),
+  ];
+  if (conversationIds && conversationIds.length > 0) {
+    filters.push(
+      inArray(memoryV2ActivationLogs.conversationId, conversationIds),
+    );
+  }
+
+  const rows = db
+    .select({
+      conversationId: memoryV2ActivationLogs.conversationId,
+      messageId: memoryV2ActivationLogs.messageId,
+      turn: memoryV2ActivationLogs.turn,
+      conceptsJson: memoryV2ActivationLogs.conceptsJson,
+      configJson: memoryV2ActivationLogs.configJson,
+      createdAt: memoryV2ActivationLogs.createdAt,
+    })
+    .from(memoryV2ActivationLogs)
+    .where(and(...filters))
+    .orderBy(
+      strategy === "random"
+        ? sql`RANDOM()`
+        : desc(memoryV2ActivationLogs.createdAt),
+    )
+    .limit(limit)
+    .all();
+
+  const turns: OracleTurn[] = [];
+  for (const row of rows) {
+    const messageId = row.messageId;
+    if (messageId == null) continue;
+
+    const anchor = db
+      .select({ createdAt: messages.createdAt })
+      .from(messages)
+      .where(eq(messages.id, messageId))
+      .limit(1)
+      .all();
+    const anchorRow = anchor[0];
+    if (!anchorRow) continue;
+
+    let concepts: MemoryV2ConceptRowRecord[];
+    let loggedConfig: MemoryV2ConfigSnapshot;
+    try {
+      concepts = JSON.parse(row.conceptsJson) as MemoryV2ConceptRowRecord[];
+      loggedConfig = JSON.parse(row.configJson) as MemoryV2ConfigSnapshot;
+    } catch {
+      continue;
+    }
+
+    const seen = new Set<string>();
+    const groundTruthSlugs: string[] = [];
+    for (const concept of concepts) {
+      if (!allowedStatuses.has(concept.status)) continue;
+      if (pageExists && !pageExists(concept.slug)) continue;
+      if (seen.has(concept.slug)) continue;
+      seen.add(concept.slug);
+      groundTruthSlugs.push(concept.slug);
+    }
+    if (groundTruthSlugs.length === 0) continue;
+
+    turns.push({
+      conversationId: row.conversationId,
+      turn: row.turn,
+      anchorMessageId: messageId,
+      anchorCreatedAt: anchorRow.createdAt,
+      groundTruthSlugs,
+      loggedConfig,
+      createdAt: row.createdAt,
+    });
+  }
+
+  return turns;
+}

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

@@ -0,0 +1,224 @@
+/**
+ * Input reconstruction — rebuild a retriever's per-turn inputs from telemetry.
+ *
+ * The activation log stores only outputs, so replaying a historical turn means
+ * reconstructing the inputs:
+ *  - `recentTurnPairs`: the (assistant, user) pairs ending at the turn's user
+ *    message, windowed by `historical_pairs` and extracted exactly as
+ *    production does (mirrors `extractRecentTurnPairs` in
+ *    `conversation-graph-memory.ts`).
+ *  - `nowText`: read from current workspace files (`loadNowText`). NOT stored
+ *    in the log, so it may differ from what the live turn saw —
+ *    always-approximate; see `ReconstructionMeta.nowReconstructedFromCurrent`.
+ *  - `priorEverInjected`: the union of injected / in_context slugs from earlier
+ *    `mode='router'` logs in the same conversation (turn < target).
+ *
+ * The anchor is the turn's assistant reply; the messages the router saw are
+ * those strictly before it, so we fetch a bounded recent window up to the
+ * anchor's timestamp and cut at the anchor row.
+ */
+
+import { and, asc, desc, eq, lt, lte } from "drizzle-orm";
+
+import type { AssistantConfig } from "../../../config/types.js";
+import type { ContentBlock } from "../../../providers/types.js";
+import type { DrizzleDb } from "../../db-connection.js";
+import type { MemoryV2ConceptRowRecord } from "../../memory-v2-activation-log-store.js";
+import { memoryV2ActivationLogs, messages } from "../../schema.js";
+import { loadNowText } from "../now-text.js";
+import type { RouterTurnPair } from "../router.js";
+import type { EverInjectedEntry } from "../types.js";
+import type { OracleTurn } from "./oracle.js";
+import type { RetrievalInput } from "./retriever.js";
+
+export interface ReconstructionMeta {
+  /** `historical_pairs` window requested. */
+  windowPairs: number;
+  /** Pairs actually reconstructed (may be < window near conversation start). */
+  pairsReconstructed: number;
+  /** `priorEverInjected` entries reconstructed from earlier router logs. */
+  priorEverInjectedCount: number;
+  /**
+   * NOW text is read from current workspace files — it is not stored in the
+   * log and may differ from what the live turn saw. Always true; a recall gap
+   * is partly attributable to this unmeasured drift.
+   */
+  nowReconstructedFromCurrent: true;
+}
+
+export interface ReconstructedInput {
+  input: RetrievalInput;
+  meta: ReconstructionMeta;
+}
+
+/** Minimal message shape for pair extraction. */
+interface PlainMessage {
+  role: string;
+  content: ContentBlock[];
+}
+
+/**
+ * Mirror of production `extractRecentTurnPairs`: walk messages newest-first,
+ * pair each user message with the preceding assistant reply, keep the last `k`
+ * pairs (oldest first). A leading user message with no prior assistant reply is
+ * emitted with an empty `assistantMessage`.
+ */
+function extractRecentTurnPairs(
+  msgs: readonly PlainMessage[],
+  k: number,
+): RouterTurnPair[] {
+  const messageText = (msg: PlainMessage): string =>
+    msg.content
+      .filter(
+        (b): b is Extract<ContentBlock, { type: "text" }> => b.type === "text",
+      )
+      .map((b) => b.text)
+      .join(" ");
+
+  const pairs: RouterTurnPair[] = [];
+  let pendingUser: string | null = null;
+  for (let i = msgs.length - 1; i >= 0 && pairs.length < k; i--) {
+    const msg = msgs[i]!;
+    if (msg.role === "user" && pendingUser === null) {
+      pendingUser = messageText(msg);
+    } else if (msg.role === "assistant" && pendingUser !== null) {
+      pairs.unshift({
+        assistantMessage: messageText(msg),
+        userMessage: pendingUser,
+      });
+      pendingUser = null;
+    }
+  }
+  if (pendingUser !== null && pairs.length < k) {
+    pairs.unshift({ assistantMessage: "", userMessage: pendingUser });
+  }
+  if (pairs.length === 0) {
+    pairs.push({ assistantMessage: "", userMessage: "" });
+  }
+  return pairs;
+}
+
+function parseContent(raw: string): ContentBlock[] {
+  try {
+    const parsed = JSON.parse(raw);
+    return Array.isArray(parsed) ? (parsed as ContentBlock[]) : [];
+  } catch {
+    return [];
+  }
+}
+
+export async function reconstructInput(
+  db: DrizzleDb,
+  turn: OracleTurn,
+  config: AssistantConfig,
+  workspaceDir: string,
+): Promise<ReconstructedInput | null> {
+  const windowPairs = config.memory.v2.router.historical_pairs;
+
+  // Fetch a bounded recent window up to the anchor's timestamp (newest first),
+  // then cut everything at/after the anchor reply. We only need the last
+  // `windowPairs` (assistant,user) pairs, so a small generous bound suffices
+  // even for very long conversations.
+  const fetchWindow = Math.max(20, windowPairs * 12);
+  const recent = db
+    .select({
+      id: messages.id,
+      role: messages.role,
+      content: messages.content,
+    })
+    .from(messages)
+    .where(
+      and(
+        eq(messages.conversationId, turn.conversationId),
+        lte(messages.createdAt, turn.anchorCreatedAt),
+      ),
+    )
+    .orderBy(desc(messages.createdAt), desc(messages.id))
+    .limit(fetchWindow)
+    .all();
+
+  const anchorPos = recent.findIndex((m) => m.id === turn.anchorMessageId);
+  if (anchorPos < 0) return null;
+  const beforeAnchor = recent.slice(anchorPos + 1);
+  if (beforeAnchor.length === 0) return null;
+
+  const plain: PlainMessage[] = beforeAnchor
+    .slice()
+    .reverse()
+    .map((m) => ({ role: m.role, content: parseContent(m.content) }));
+
+  const recentTurnPairs = extractRecentTurnPairs(plain, windowPairs);
+  const priorEverInjected = reconstructPriorEverInjected(
+    db,
+    turn.conversationId,
+    turn.turn,
+  );
+  const nowText = await loadNowText(workspaceDir);
+
+  return {
+    input: {
+      workspaceDir,
+      recentTurnPairs,
+      nowText,
+      priorEverInjected,
+      config,
+    },
+    meta: {
+      windowPairs,
+      pairsReconstructed: recentTurnPairs.length,
+      priorEverInjectedCount: priorEverInjected.length,
+      nowReconstructedFromCurrent: true,
+    },
+  };
+}
+
+const PRIOR_STATUSES = new Set<string>(["injected", "in_context"]);
+
+/**
+ * Union of slugs injected on earlier `mode='router'` turns in this conversation
+ * (turn < `currentTurn`), each tagged with the earliest turn it appeared on —
+ * the harness analogue of the running `everInjected` list production maintains.
+ */
+function reconstructPriorEverInjected(
+  db: DrizzleDb,
+  conversationId: string,
+  currentTurn: number,
+): EverInjectedEntry[] {
+  const rows = db
+    .select({
+      turn: memoryV2ActivationLogs.turn,
+      conceptsJson: memoryV2ActivationLogs.conceptsJson,
+    })
+    .from(memoryV2ActivationLogs)
+    .where(
+      and(
+        eq(memoryV2ActivationLogs.conversationId, conversationId),
+        eq(memoryV2ActivationLogs.mode, "router"),
+        lt(memoryV2ActivationLogs.turn, currentTurn),
+      ),
+    )
+    .orderBy(asc(memoryV2ActivationLogs.turn))
+    .all();
+
+  const firstTurnBySlug = new Map<string, number>();
+  for (const row of rows) {
+    let concepts: MemoryV2ConceptRowRecord[];
+    try {
+      concepts = JSON.parse(row.conceptsJson) as MemoryV2ConceptRowRecord[];
+    } catch {
+      continue;
+    }
+    for (const concept of concepts) {
+      if (!PRIOR_STATUSES.has(concept.status)) continue;
+      if (!firstTurnBySlug.has(concept.slug)) {
+        firstTurnBySlug.set(concept.slug, row.turn);
+      }
+    }
+  }
+
+  const entries: EverInjectedEntry[] = [];
+  firstTurnBySlug.forEach((turn, slug) => {
+    entries.push({ slug, turn });
+  });
+  return entries;
+}

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

@@ -0,0 +1,74 @@
+/**
+ * The retriever seam for the memory comparison harness.
+ *
+ * A `Retriever` maps one turn's reconstructed context to a set of selected
+ * concept-page slugs. Multiple strategies (the production router, an
+ * alternative retrieval loop) implement this single interface, so the harness
+ * can run them over the same turns and diff their selections against the oracle
+ * (see `oracle.ts`). Offline only — nothing here runs in the live injection
+ * path.
+ */
+
+import type { AssistantConfig } from "../../../config/types.js";
+import type { RouterTurnPair } from "../router.js";
+import type { EverInjectedEntry } from "../types.js";
+import type { DescentTrace } from "./trace.js";
+
+/**
+ * Per-turn context a retriever needs, mirroring the live router's inputs
+ * (`RunRouterParams`). Reconstructed from historical telemetry by
+ * `reconstructInput` (see `replay-input.ts`).
+ */
+export interface RetrievalInput {
+  workspaceDir: string;
+  /**
+   * Recent (assistant, user) pairs, oldest first. The last entry's
+   * `userMessage` is the just-arrived turn being routed.
+   */
+  recentTurnPairs: readonly RouterTurnPair[];
+  /** NOW context (essentials/threads/recent), verbatim. */
+  nowText: string;
+  /** Slugs already injected on prior turns. */
+  priorEverInjected: readonly EverInjectedEntry[];
+  config: AssistantConfig;
+  signal?: AbortSignal;
+}
+
+/** Optional cost accounting for a single retrieval. */
+export interface RetrievalCost {
+  inputTokens?: number;
+  outputTokens?: number;
+  usd?: number;
+  ms?: number;
+}
+
+/** What a retriever returns for one turn. */
+export interface RetrievalOutput {
+  /** Selected page slugs, in the retriever's own ranked order. */
+  selectedSlugs: string[];
+  /**
+   * Per-slug provenance / lane label, retriever-defined — router tiers
+   * (`tier1`, `tier3:0`, …) for the current router, or loop lanes (`sparse`,
+   * `dense`, `tree`, `edge`) for the future loop. Drives per-lane attribution
+   * in `metrics.ts`.
+   */
+  sourceBySlug: ReadonlyMap<string, string>;
+  /**
+   * Loop-only descent trace. Tier-based retrievers (the current router) have
+   * no tree walk and leave this `undefined`; renderers show "(no descent
+   * trace)".
+   */
+  trace?: DescentTrace;
+  cost?: RetrievalCost;
+  /** Non-null when the retriever could not produce a usable selection. */
+  failureReason?: string | null;
+}
+
+/**
+ * A named retrieval strategy. Implementations must not mutate production state
+ * — the harness runs them offline over historical turns.
+ */
+export interface Retriever {
+  readonly name: string;
+  retrieve(input: RetrievalInput): Promise<RetrievalOutput>;
+}

package/src/memory/v2/harness/router-retriever.ts

@@ -0,0 +1,43 @@
+/**
+ * Router retriever — the current production router (`runRouter`) adapted to the
+ * harness `Retriever` interface.
+ *
+ * The union cap is left ON (no `disableUnionCap`) so the selection matches what
+ * production would actually inject — the self-test grades the router against
+ * its own injected ground truth.
+ */
+
+import type { DrizzleDb } from "../../db-connection.js";
+import { runRouter } from "../router.js";
+import type {
+  RetrievalInput,
+  RetrievalOutput,
+  Retriever,
+} from "./retriever.js";
+
+/**
+ * @param database optional handle for tier-2 EMA scoring, forwarded to
+ * `runRouter`. Omit to exercise only the tier-1 / tier-3 paths (as the router's
+ * own tests do).
+ */
+export function createRouterRetriever(database?: DrizzleDb): Retriever {
+  return {
+    name: "router",
+    async retrieve(input: RetrievalInput): Promise<RetrievalOutput> {
+      const result = await runRouter({
+        workspaceDir: input.workspaceDir,
+        recentTurnPairs: input.recentTurnPairs,
+        nowText: input.nowText,
+        priorEverInjected: input.priorEverInjected,
+        config: input.config,
+        ...(input.signal ? { signal: input.signal } : {}),
+        ...(database ? { database } : {}),
+      });
+      return {
+        selectedSlugs: result.selectedSlugs,
+        sourceBySlug: result.sourceBySlug,
+        failureReason: result.failureReason,
+      };
+    },
+  };
+}