@vellumai/assistant 0.7.1 → 0.7.3

package/src/memory/memory-v2-activation-log-store.ts

@@ -12,18 +12,35 @@ export interface MemoryV2ConceptRowRecord {
   simUser: number;
   simAssistant: number;
   simNow: number;
+  /**
+   * Cross-encoder rerank delta in raw rerank space (`alpha · r_norm_u`)
+   * for the user channel. Zero when rerank is disabled or the slug fell
+   * outside the unified top-K-by-pre-rerank-A_o window. Applied
+   * additively to A_o weighted by `c_user` — `simUser` itself is the
+   * raw fused score and never carries the boost. Stored as a JSON field,
+   * so older log rows pre-date this addition and decode with `undefined`;
+   * readers should fall back to 0.
+   */
+  simUserRerankBoost: number;
+  /**
+   * Cross-encoder rerank delta for the assistant channel. Same semantics
+   * as `simUserRerankBoost`, weighted by `c_assistant` when applied to
+   * A_o. The NOW channel intentionally bypasses rerank, so there is no
+   * `simNowRerankBoost`.
+   */
+  simAssistantRerankBoost: number;
+  /**
+   * True when rerank ran and this slug landed in the unified
+   * top-K-by-pre-rerank-A_o pool. Distinguishes "cross-encoder evaluated
+   * this and chose 0" from "rerank skipped this slug" so the inspector
+   * can keep the rerank rows visible at `+0.000` instead of silently
+   * dropping them. Older log rows pre-date this field and decode with
+   * `undefined`; readers should fall back to `false`.
+   */
+  inRerankPool: boolean;
   spreadContribution: number;
   source: "prior_state" | "ann_top50" | "both";
-  status: "in_context" | "injected" | "not_injected";
-}
-
-export interface MemoryV2SkillRowRecord {
-  id: string;
-  activation: number;
-  simUser: number;
-  simAssistant: number;
-  simNow: number;
-  status: "injected" | "not_injected";
+  status: "in_context" | "injected" | "not_injected" | "page_missing";
 }
 
 export interface MemoryV2ConfigSnapshot {
@@ -34,7 +51,6 @@ export interface MemoryV2ConfigSnapshot {
   k: number;
   hops: number;
   top_k: number;
-  top_k_skills: number;
   epsilon: number;
 }
 
@@ -43,7 +59,6 @@ export interface RecordMemoryV2ActivationLogParams {
   turn: number;
   mode: "context-load" | "per-turn";
   concepts: MemoryV2ConceptRowRecord[];
-  skills: MemoryV2SkillRowRecord[];
   config: MemoryV2ConfigSnapshot;
 }
 
@@ -51,6 +66,11 @@ export function recordMemoryV2ActivationLog(
   params: RecordMemoryV2ActivationLogParams,
 ): void {
   const db = getDb();
+  // Skills now live as concept rows under `slug: "skills/<id>"`, so the
+  // separate `skills_json` column is always written empty. The column itself
+  // remains in the schema for backwards-compat with prior log rows; the
+  // reader drops it. A future migration can DROP the column once those rows
+  // age out of relevance.
   db.insert(memoryV2ActivationLogs)
     .values({
       id: uuid(),
@@ -59,7 +79,7 @@ export function recordMemoryV2ActivationLog(
       turn: params.turn,
       mode: params.mode,
       conceptsJson: JSON.stringify(params.concepts),
-      skillsJson: JSON.stringify(params.skills),
+      skillsJson: "[]",
       configJson: JSON.stringify(params.config),
       createdAt: Date.now(),
     })
@@ -87,7 +107,6 @@ export interface MemoryV2ActivationLog {
   turn: number;
   mode: "context-load" | "per-turn";
   concepts: MemoryV2ConceptRowRecord[];
-  skills: MemoryV2SkillRowRecord[];
   config: MemoryV2ConfigSnapshot;
 }
 
@@ -109,7 +128,6 @@ export function getMemoryV2ActivationLogByMessageIds(
     turn: row.turn,
     mode: row.mode as "context-load" | "per-turn",
     concepts: JSON.parse(row.conceptsJson) as MemoryV2ConceptRowRecord[],
-    skills: JSON.parse(row.skillsJson) as MemoryV2SkillRowRecord[],
     config: JSON.parse(row.configJson) as MemoryV2ConfigSnapshot,
   };
 }

package/src/memory/memory-v2-concept-frequency.ts

@@ -0,0 +1,169 @@
+import type { MemoryV2ConceptRowRecord } from "./memory-v2-activation-log-store.js";
+import { rawAll, rawGet } from "./raw-query.js";
+import { listPages } from "./v2/page-store.js";
+
+type ConceptStatus = MemoryV2ConceptRowRecord["status"];
+
+export type ConceptFrequencyCounts = Record<ConceptStatus, number>;
+
+export interface ConceptFrequencyRow {
+  slug: string;
+  counts: ConceptFrequencyCounts;
+  totalEvaluations: number;
+  lastInjectedAt: number | null;
+  /** Whether the slug currently has a markdown page on disk. */
+  onDisk: boolean;
+}
+
+export interface ConceptFrequencyResponse {
+  filters: {
+    conversationId: string | null;
+    sinceMs: number | null;
+  };
+  totals: {
+    /** Activation log rows scanned (turns of evaluation in the window). */
+    logCount: number;
+    /** Sum of per-row concept evaluations across all log rows in the window. */
+    conceptOccurrences: number;
+  };
+  /** Per-slug aggregates, sorted by `totalEvaluations` desc, then slug asc. */
+  concepts: ConceptFrequencyRow[];
+  /**
+   * Slugs present on disk that never appeared in any activation log row in
+   * the window — i.e. retrieval never even scored them as a candidate.
+   */
+  neverEvaluatedSlugs: string[];
+}
+
+export interface GetConceptFrequencyFilters {
+  conversationId?: string;
+  sinceMs?: number;
+}
+
+interface AggRow {
+  slug: string | null;
+  status: ConceptStatus | string | null;
+  count: number;
+  last_seen: number;
+}
+
+const ZERO_COUNTS: ConceptFrequencyCounts = {
+  injected: 0,
+  in_context: 0,
+  not_injected: 0,
+  page_missing: 0,
+};
+
+interface CountRow {
+  count: number;
+}
+
+export async function getConceptFrequencySummary(
+  workspaceDir: string,
+  filters: GetConceptFrequencyFilters = {},
+): Promise<ConceptFrequencyResponse> {
+  const conversationId = filters.conversationId ?? null;
+  const sinceMs = filters.sinceMs ?? null;
+
+  // Kick off the on-disk page walk in parallel with the (synchronous) SQL
+  // queries below — listPages does fs.readdir, rawAll/rawGet are sync.
+  const onDiskSlugsPromise = listPages(workspaceDir);
+
+  const aggRows = rawAll<AggRow>(
+    `SELECT
+       json_extract(c.value, '$.slug')   AS slug,
+       json_extract(c.value, '$.status') AS status,
+       COUNT(*)                          AS count,
+       MAX(l.created_at)                 AS last_seen
+     FROM memory_v2_activation_logs l, json_each(l.concepts_json) c
+     WHERE (? IS NULL OR l.conversation_id = ?)
+       AND (? IS NULL OR l.created_at >= ?)
+     GROUP BY slug, status`,
+    conversationId,
+    conversationId,
+    sinceMs,
+    sinceMs,
+  );
+
+  const logCountRow = rawGet<CountRow>(
+    `SELECT COUNT(*) AS count
+       FROM memory_v2_activation_logs
+       WHERE (? IS NULL OR conversation_id = ?)
+         AND (? IS NULL OR created_at >= ?)`,
+    conversationId,
+    conversationId,
+    sinceMs,
+    sinceMs,
+  );
+
+  const bySlug = new Map<string, ConceptFrequencyRow>();
+  let conceptOccurrences = 0;
+
+  for (const row of aggRows) {
+    if (!row.slug) continue;
+    let entry = bySlug.get(row.slug);
+    if (!entry) {
+      entry = {
+        slug: row.slug,
+        counts: { ...ZERO_COUNTS },
+        totalEvaluations: 0,
+        lastInjectedAt: null,
+        onDisk: false,
+      };
+      bySlug.set(row.slug, entry);
+    }
+
+    switch (row.status) {
+      case "injected":
+        entry.counts.injected += row.count;
+        entry.lastInjectedAt =
+          entry.lastInjectedAt === null
+            ? row.last_seen
+            : Math.max(entry.lastInjectedAt, row.last_seen);
+        break;
+      case "in_context":
+        entry.counts.in_context += row.count;
+        break;
+      case "not_injected":
+        entry.counts.not_injected += row.count;
+        break;
+      case "page_missing":
+        entry.counts.page_missing += row.count;
+        break;
+      default:
+        // Forward-compat: unknown status values are ignored, not summed into
+        // totalEvaluations. The activation pipeline produces a closed enum.
+        continue;
+    }
+    entry.totalEvaluations += row.count;
+    conceptOccurrences += row.count;
+  }
+
+  const onDiskSlugs = new Set(await onDiskSlugsPromise);
+  for (const entry of bySlug.values()) {
+    entry.onDisk = onDiskSlugs.has(entry.slug);
+  }
+
+  const neverEvaluatedSlugs: string[] = [];
+  for (const slug of onDiskSlugs) {
+    if (!bySlug.has(slug)) neverEvaluatedSlugs.push(slug);
+  }
+  neverEvaluatedSlugs.sort();
+
+  const concepts = [...bySlug.values()].sort((a, b) => {
+    if (b.totalEvaluations !== a.totalEvaluations) {
+      return b.totalEvaluations - a.totalEvaluations;
+    }
+    return a.slug.localeCompare(b.slug);
+  });
+
+  return {
+    filters: { conversationId, sinceMs },
+    totals: {
+      logCount: logCountRow?.count ?? 0,
+      conceptOccurrences,
+    },
+    concepts,
+    neverEvaluatedSlugs,
+  };
+}

package/src/memory/migrations/237-heartbeat-runs.ts

@@ -0,0 +1,45 @@
+import type { DrizzleDb } from "../db-connection.js";
+import { getSqliteFrom } from "../db-connection.js";
+import { tableHasColumn } from "./schema-introspection.js";
+import { withCrashRecovery } from "./validate-migration-state.js";
+
+const CHECKPOINT_KEY = "migration_heartbeat_runs_v1";
+
+/**
+ * Create the heartbeat_runs table for tracking heartbeat execution lifecycle.
+ *
+ * Each row represents one scheduled heartbeat tick, tracking its progression
+ * through the status lifecycle: pending -> running -> ok/error/timeout, or
+ * pending -> skipped/missed/superseded.
+ */
+export function migrateHeartbeatRuns(database: DrizzleDb): void {
+  withCrashRecovery(database, CHECKPOINT_KEY, () => {
+    if (tableHasColumn(database, "heartbeat_runs", "id")) {
+      return;
+    }
+    const raw = getSqliteFrom(database);
+    raw.exec(/*sql*/ `
+      CREATE TABLE IF NOT EXISTS heartbeat_runs (
+        id TEXT PRIMARY KEY,
+        scheduled_for INTEGER NOT NULL,
+        started_at INTEGER,
+        finished_at INTEGER,
+        duration_ms INTEGER,
+        status TEXT NOT NULL,
+        skip_reason TEXT,
+        error TEXT,
+        conversation_id TEXT,
+        created_at INTEGER NOT NULL
+      )
+    `);
+    raw.exec(/*sql*/ `
+      CREATE INDEX IF NOT EXISTS idx_heartbeat_runs_scheduled_for
+        ON heartbeat_runs (scheduled_for)
+    `);
+  });
+}
+
+export function downHeartbeatRuns(database: DrizzleDb): void {
+  const raw = getSqliteFrom(database);
+  raw.exec(/*sql*/ `DROP TABLE IF EXISTS heartbeat_runs`);
+}

package/src/memory/migrations/238-schedule-retry-policy.ts

@@ -0,0 +1,20 @@
+import type { DrizzleDb } from "../db-connection.js";
+import { getSqliteFrom } from "../db-connection.js";
+
+export function migrateScheduleRetryPolicy(database: DrizzleDb): void {
+  const raw = getSqliteFrom(database);
+  try {
+    raw.exec(
+      `ALTER TABLE cron_jobs ADD COLUMN max_retries INTEGER NOT NULL DEFAULT 3`,
+    );
+  } catch {
+    /* Column already exists */
+  }
+  try {
+    raw.exec(
+      `ALTER TABLE cron_jobs ADD COLUMN retry_backoff_ms INTEGER NOT NULL DEFAULT 60000`,
+    );
+  } catch {
+    /* Column already exists */
+  }
+}

package/src/memory/migrations/239-trace-events-created-at-index.ts

@@ -0,0 +1,18 @@
+import type { DrizzleDb } from "../db-connection.js";
+import { getSqliteFrom } from "../db-connection.js";
+import { withCrashRecovery } from "./validate-migration-state.js";
+
+const CHECKPOINT_KEY = "migration_trace_events_created_at_index_v1";
+
+/**
+ * Add an index on `trace_events.created_at` so the periodic prune job
+ * can locate expired rows without a full table scan.
+ */
+export function migrateTraceEventsCreatedAtIndex(database: DrizzleDb): void {
+  withCrashRecovery(database, CHECKPOINT_KEY, () => {
+    const raw = getSqliteFrom(database);
+    raw.exec(
+      `CREATE INDEX IF NOT EXISTS idx_trace_events_created_at ON trace_events(created_at)`,
+    );
+  });
+}

package/src/memory/migrations/index.ts

@@ -195,6 +195,12 @@ export {
   downToolInvocationsMatchedRuleId,
   migrateToolInvocationsMatchedRuleId,
 } from "./236-tool-invocations-matched-rule-id.js";
+export {
+  downHeartbeatRuns,
+  migrateHeartbeatRuns,
+} from "./237-heartbeat-runs.js";
+export { migrateScheduleRetryPolicy } from "./238-schedule-retry-policy.js";
+export { migrateTraceEventsCreatedAtIndex } from "./239-trace-events-created-at-index.js";
 export {
   MIGRATION_REGISTRY,
   type MigrationRegistryEntry,

package/src/memory/migrations/registry.ts

@@ -47,6 +47,7 @@ import { downActivationState } from "./232-activation-state.js";
 import { downMemoryV2ActivationLogs } from "./234-memory-v2-activation-logs.js";
 import { downSlackCompactionWatermark } from "./235-slack-compaction-watermark.js";
 import { downToolInvocationsMatchedRuleId } from "./236-tool-invocations-matched-rule-id.js";
+import { downHeartbeatRuns } from "./237-heartbeat-runs.js";
 
 export interface MigrationRegistryEntry {
   /** The checkpoint key written to memory_checkpoints on completion. */
@@ -404,6 +405,13 @@ export const MIGRATION_REGISTRY: MigrationRegistryEntry[] = [
       "Add matched_trust_rule_id column to tool_invocations for trust rule audit and rule editor UI",
     down: downToolInvocationsMatchedRuleId,
   },
+  {
+    key: "migration_heartbeat_runs_v1",
+    version: 47,
+    description:
+      "Create heartbeat_runs table for tracking heartbeat execution lifecycle with CAS state transitions",
+    down: downHeartbeatRuns,
+  },
 ];
 
 export function getMaxMigrationVersion(): number {

package/src/memory/pkb/pkb-search.test.ts

@@ -1,6 +1,12 @@
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
 import { makeMockLogger } from "../../__tests__/helpers/mock-logger.js";
+import { _setOverridesForTesting } from "../../config/assistant-feature-flags.js";
+
+// This test exercises the v1 PKB search path. The `memory-v2-enabled` flag
+// (registry default `true`) makes pkb-search short-circuit to keep traffic
+// off the legacy collection — disable it so the v1 path stays under test.
+_setOverridesForTesting({ "memory-v2-enabled": false });
 
 mock.module("../../util/logger.js", () => ({
   getLogger: () => makeMockLogger(),

package/src/memory/pkb/pkb-search.ts

@@ -2,7 +2,9 @@
 // PKB — Qdrant hybrid search for indexed PKB markdown files
 // ---------------------------------------------------------------------------
 
+import { getConfig } from "../../config/loader.js";
 import { getLogger } from "../../util/logger.js";
+import { isMemoryV2ReadActive } from "../context-search/sources/memory-v2.js";
 import {
   isQdrantBreakerOpen,
   withQdrantBreaker,
@@ -40,6 +42,11 @@ export async function searchPkbFiles(
   limit: number,
   scopeIds?: string[],
 ): Promise<PkbSearchResult[]> {
+  // v2 owns the read path when both gates are on; v2 absorbs PKB as a read
+  // source, so PKB hint search short-circuits to keep traffic off the v1
+  // collection (avoiding OOM-crash risk from a corrupted sparse segment).
+  if (isMemoryV2ReadActive(getConfig())) return [];
+
   if (isQdrantBreakerOpen()) {
     log.warn("Qdrant circuit breaker open, skipping PKB search");
     return [];

package/src/memory/qdrant-client.ts

@@ -73,19 +73,31 @@ export interface QdrantSearchResult {
   payload: QdrantPointPayload;
 }
 
+/**
+ * Strip a trailing `:sparse-v<digits>` segment from a sentinel string.
+ *
+ * Legacy v1 sentinels (pre-decouple) included the sparse encoder version in
+ * the embedding-model identity. The suffix is no longer written, but stored
+ * sentinels written by older daemons may still carry it — strip it before
+ * comparing identities so existing collections aren't unnecessarily rebuilt.
+ */
+export function stripLegacySparseSuffix(sentinel: string): string {
+  return sentinel.replace(/:sparse-v\d+$/, "");
+}
+
 let _instance: VellumQdrantClient | null = null;
 
 export function getQdrantClient(): VellumQdrantClient {
   if (!_instance) {
     throw new Error(
-      "Qdrant client not initialized. Call initQdrantClient() first."
+      "Qdrant client not initialized. Call initQdrantClient() first.",
     );
   }
   return _instance;
 }
 
 export function initQdrantClient(
-  config: QdrantClientConfig
+  config: QdrantClientConfig,
 ): VellumQdrantClient {
   _instance = new VellumQdrantClient(config);
   return _instance;
@@ -140,12 +152,28 @@ export class VellumQdrantClient {
           const dimMismatch =
             currentSize != null && currentSize !== this.vectorSize;
 
-          // Check model identity via a sentinel point that stores the embedding model
+          // Check model identity via a sentinel point that stores the embedding model.
+          //
+          // Legacy sentinels included a ":sparse-v<N>" suffix that conflated the
+          // sparse encoder version with the dense model identity. Sparse vectors
+          // are upserted in place and never require collection recreation, so a
+          // stored value matching the current dense identity after stripping any
+          // legacy sparse suffix is treated as compatible. Compatible-but-legacy
+          // sentinels are rewritten to the new format below to clean up gradually.
           let modelMismatch = false;
+          let needsSentinelRewrite = false;
           if (this.embeddingModel) {
             const sentinel = await this.readSentinel();
-            if (sentinel && sentinel !== this.embeddingModel) {
-              modelMismatch = true;
+            if (sentinel) {
+              const normalizedStored = stripLegacySparseSuffix(sentinel);
+              const normalizedCurrent = stripLegacySparseSuffix(
+                this.embeddingModel,
+              );
+              if (normalizedStored !== normalizedCurrent) {
+                modelMismatch = true;
+              } else if (sentinel !== this.embeddingModel) {
+                needsSentinelRewrite = true;
+              }
             }
           }
 
@@ -156,7 +184,7 @@ export class VellumQdrantClient {
                 currentSize,
                 expectedSize: this.vectorSize,
               },
-              "Qdrant collection uses unnamed vectors (legacy) — deleting and recreating with named vectors. Embeddings will be re-indexed."
+              "Qdrant collection uses unnamed vectors (legacy) — deleting and recreating with named vectors. Embeddings will be re-indexed.",
             );
             await this.client.deleteCollection(this.collection);
             migrated = true;
@@ -169,7 +197,7 @@ export class VellumQdrantClient {
                 expectedSize: this.vectorSize,
                 modelMismatch,
               },
-              "Qdrant collection incompatible (dimension or model change) — deleting and recreating. Embeddings will be regenerated on demand."
+              "Qdrant collection incompatible (dimension or model change) — deleting and recreating. Embeddings will be regenerated on demand.",
             );
             await this.client.deleteCollection(this.collection);
             migrated = true;
@@ -178,12 +206,15 @@ export class VellumQdrantClient {
             if (await this.ensurePayloadIndexesSafe()) {
               this.collectionReady = true;
             }
+            if (needsSentinelRewrite && this.embeddingModel) {
+              await this.writeSentinel(this.embeddingModel);
+            }
             return { migrated: false };
           }
         } catch (err) {
           log.warn(
             { err },
-            "Failed to verify collection compatibility, assuming compatible"
+            "Failed to verify collection compatibility, assuming compatible",
           );
           if (await this.ensurePayloadIndexesSafe()) {
             this.collectionReady = true;
@@ -197,7 +228,7 @@ export class VellumQdrantClient {
 
     log.info(
       { collection: this.collection, vectorSize: this.vectorSize },
-      "Creating Qdrant collection with named vectors (dense + sparse)"
+      "Creating Qdrant collection with named vectors (dense + sparse)",
     );
 
     try {
@@ -253,7 +284,7 @@ export class VellumQdrantClient {
       this.collectionReady = true;
       log.info(
         { collection: this.collection },
-        "Qdrant collection created with payload indexes"
+        "Qdrant collection created with payload indexes",
       );
     }
 
@@ -265,7 +296,7 @@ export class VellumQdrantClient {
     targetId: string,
     vector: number[],
     payload: Omit<QdrantPointPayload, "target_type" | "target_id">,
-    sparseVector?: QdrantSparseVector
+    sparseVector?: QdrantSparseVector,
   ): Promise<string> {
     await this.ensureCollection();
 
@@ -320,7 +351,7 @@ export class VellumQdrantClient {
   async search(
     vector: number[],
     limit: number,
-    filter?: Record<string, unknown>
+    filter?: Record<string, unknown>,
   ): Promise<QdrantSearchResult[]> {
     await this.ensureCollection();
 
@@ -348,7 +379,7 @@ export class VellumQdrantClient {
     return results.map((result) => ({
       id: typeof result.id === "string" ? result.id : String(result.id),
       score: result.score,
-      payload: (result.payload as unknown) as QdrantPointPayload,
+      payload: result.payload as unknown as QdrantPointPayload,
     }));
   }
 
@@ -357,7 +388,6 @@ export class VellumQdrantClient {
     limit: number,
     targetTypes: Array<"segment" | "item" | "summary" | "media">,
     excludeMessageIds?: string[],
-    scopeIds?: string[]
   ): Promise<QdrantSearchResult[]> {
     const mustConditions: Array<Record<string, unknown>> = [
       {
@@ -384,18 +414,6 @@ export class VellumQdrantClient {
       });
     }
 
-    // Scope filtering: accept points whose memory_scope_id matches one of the
-    // allowed scopes, OR points that lack the field entirely (legacy data).
-    // Post-query DB filtering remains as defense-in-depth for legacy points.
-    if (scopeIds && scopeIds.length > 0) {
-      mustConditions.push({
-        should: [
-          { key: "memory_scope_id", match: { any: scopeIds } },
-          { is_empty: { key: "memory_scope_id" } },
-        ],
-      });
-    }
-
     const mustNotConditions: Array<Record<string, unknown>> = [
       { key: "_meta", match: { value: true } },
     ];
@@ -434,7 +452,7 @@ export class VellumQdrantClient {
     const queryParams = {
       prefetch: [
         {
-          query: (denseVector as unknown) as number[],
+          query: denseVector as unknown as number[],
           using: "dense",
           limit: effectivePrefetchLimit,
         },
@@ -469,7 +487,7 @@ export class VellumQdrantClient {
     return (results.points ?? []).map((point) => ({
       id: typeof point.id === "string" ? point.id : String(point.id),
       score: point.score ?? 0,
-      payload: (point.payload as unknown) as QdrantPointPayload,
+      payload: point.payload as unknown as QdrantPointPayload,
     }));
   }
 
@@ -594,7 +612,7 @@ export class VellumQdrantClient {
     } catch (err) {
       log.warn(
         { err, collection: this.collection },
-        "Failed to delete Qdrant collection"
+        "Failed to delete Qdrant collection",
       );
       return false;
     }
@@ -762,8 +780,7 @@ export class VellumQdrantClient {
           ...(offset !== undefined ? { offset } : {}),
         });
         for (const point of result.points) {
-          const id =
-            typeof point.id === "string" ? point.id : String(point.id);
+          const id = typeof point.id === "string" ? point.id : String(point.id);
           const payload = (point.payload ?? {}) as Record<string, unknown>;
           out.push({ id, payload });
         }
@@ -788,7 +805,7 @@ export class VellumQdrantClient {
 
   private async findByTarget(
     targetType: string,
-    targetId: string
+    targetId: string,
   ): Promise<string | null> {
     try {
       const results = await this.client.scroll(this.collection, {