@vellumai/assistant 0.6.5 → 0.7.0

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

@@ -1,8 +1,9 @@
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
+import { makeMockLogger } from "../../__tests__/helpers/mock-logger.js";
+
 mock.module("../../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, { get: () => () => {} }),
+  getLogger: () => makeMockLogger(),
 }));
 
 // Mutable breaker state + capture buffers for assertions.
@@ -20,11 +21,18 @@ const searchCalls: Array<{
   filter?: unknown;
 }> = [];
 
-type Payload = { target_type: string; target_id: string; path?: string };
+type Payload = {
+  target_type: string;
+  target_id: string;
+  path?: string;
+  text?: string;
+};
 type ScoredPoint = { id: string; score: number; payload: Payload };
 
 let hybridResults: ScoredPoint[] = [];
 let denseResults: ScoredPoint[] = [];
+let hybridThrows: Error | null = null;
+let denseThrows: Error | null = null;
 
 mock.module("../qdrant-circuit-breaker.js", () => ({
   isQdrantBreakerOpen: () => breakerOpen,
@@ -41,6 +49,7 @@ mock.module("../qdrant-client.js", () => ({
       prefetchLimit?: number;
     }) => {
       hybridSearchCalls.push(params);
+      if (hybridThrows) throw hybridThrows;
       return hybridResults;
     },
     search: async (
@@ -49,9 +58,11 @@ mock.module("../qdrant-client.js", () => ({
       filter?: Record<string, unknown>,
     ) => {
       searchCalls.push({ vector, limit, filter });
+      if (denseThrows) throw denseThrows;
       return denseResults;
     },
   }),
+  resolveQdrantUrl: () => "http://127.0.0.1:6333",
 }));
 
 const { searchPkbFiles } = await import("./pkb-search.js");
@@ -63,6 +74,8 @@ describe("searchPkbFiles", () => {
     searchCalls.length = 0;
     hybridResults = [];
     denseResults = [];
+    hybridThrows = null;
+    denseThrows = null;
   });
 
   test("filter payload targets pkb_file (hybrid path runs both queries)", async () => {
@@ -236,7 +249,81 @@ describe("searchPkbFiles", () => {
     expect(other?.hybridScore).toBeUndefined();
   });
 
-  test("result present only in hybrid returns denseScore=0 and a hybridScore", async () => {
+  test("propagates snippet from the best matching chunk without changing ranking", async () => {
+    denseResults = [
+      {
+        id: "chunk-1",
+        score: 0.9,
+        payload: {
+          target_type: "pkb_file",
+          target_id: "t-1",
+          path: "/notes/same.md",
+          text: "Dense best chunk.",
+        },
+      },
+      {
+        id: "chunk-2",
+        score: 0.5,
+        payload: {
+          target_type: "pkb_file",
+          target_id: "t-2",
+          path: "/notes/same.md",
+          text: "Dense weaker chunk.",
+        },
+      },
+      {
+        id: "chunk-3",
+        score: 0.7,
+        payload: {
+          target_type: "pkb_file",
+          target_id: "t-3",
+          path: "/notes/other.md",
+          text: "Other dense chunk.",
+        },
+      },
+    ];
+    hybridResults = [
+      {
+        id: "chunk-2",
+        score: 0.04,
+        payload: {
+          target_type: "pkb_file",
+          target_id: "t-2",
+          path: "/notes/same.md",
+          text: "Hybrid best chunk.",
+        },
+      },
+      {
+        id: "chunk-1",
+        score: 0.02,
+        payload: {
+          target_type: "pkb_file",
+          target_id: "t-1",
+          path: "/notes/same.md",
+          text: "Hybrid weaker chunk.",
+        },
+      },
+    ];
+
+    const results = await searchPkbFiles(
+      [0.1],
+      { indices: [1], values: [1] },
+      10,
+    );
+
+    expect(results.map((r) => r.path)).toEqual([
+      "/notes/same.md",
+      "/notes/other.md",
+    ]);
+    const same = results.find((r) => r.path === "/notes/same.md");
+    const other = results.find((r) => r.path === "/notes/other.md");
+    expect(same?.denseScore).toBe(0.9);
+    expect(same?.hybridScore).toBe(0.04);
+    expect(same?.snippet).toBe("Hybrid best chunk.");
+    expect(other?.snippet).toBe("Other dense chunk.");
+  });
+
+  test("hybrid-only hits (no dense match) are dropped so they can't evict dense-qualified paths before the slice", async () => {
     denseResults = [
       {
         id: "a",
@@ -248,6 +335,10 @@ describe("searchPkbFiles", () => {
         },
       },
     ];
+    // `b` appears only in the hybrid response (outside the dense prefetch).
+    // It has no cosine score, so it can never pass a downstream threshold
+    // and must not be surfaced — otherwise it could crowd out dense-qualified
+    // hits before the caller gates on denseScore.
     hybridResults = [
       {
         id: "a",
@@ -275,12 +366,62 @@ describe("searchPkbFiles", () => {
       10,
     );
 
+    expect(results).toHaveLength(1);
     const a = results.find((r) => r.path === "/notes/a.md");
-    const b = results.find((r) => r.path === "/notes/b.md");
     expect(a?.denseScore).toBe(0.8);
     expect(a?.hybridScore).toBe(0.03);
-    expect(b?.denseScore).toBe(0);
-    expect(b?.hybridScore).toBe(0.02);
+    expect(results.find((r) => r.path === "/notes/b.md")).toBeUndefined();
+  });
+
+  test("hybrid failure (transient) falls back to dense-only results", async () => {
+    denseResults = [
+      {
+        id: "a",
+        score: 0.8,
+        payload: {
+          target_type: "pkb_file",
+          target_id: "t-1",
+          path: "/notes/a.md",
+        },
+      },
+    ];
+    hybridThrows = new Error("qdrant hybrid transient failure");
+
+    const results = await searchPkbFiles(
+      [0.1],
+      { indices: [1], values: [1] },
+      10,
+    );
+
+    expect(results).toHaveLength(1);
+    expect(results[0]?.path).toBe("/notes/a.md");
+    expect(results[0]?.denseScore).toBe(0.8);
+    expect(results[0]?.hybridScore).toBeUndefined();
+  });
+
+  test("dense failure (transient) falls back to empty results even if hybrid succeeded", async () => {
+    denseThrows = new Error("qdrant dense transient failure");
+    hybridResults = [
+      {
+        id: "a",
+        score: 0.03,
+        payload: {
+          target_type: "pkb_file",
+          target_id: "t-1",
+          path: "/notes/a.md",
+        },
+      },
+    ];
+
+    // Without a dense cosine score there is nothing to gate on, so the
+    // hybrid-only fallback surfaces no results.
+    const results = await searchPkbFiles(
+      [0.1],
+      { indices: [1], values: [1] },
+      10,
+    );
+
+    expect(results).toEqual([]);
   });
 
   test("empty Qdrant response yields []", async () => {

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

@@ -7,12 +7,13 @@ import {
   isQdrantBreakerOpen,
   withQdrantBreaker,
 } from "../qdrant-circuit-breaker.js";
-import {
-  getQdrantClient,
-  type QdrantSearchResult,
-  type QdrantSparseVector,
+import type {
+  QdrantSearchResult,
+  QdrantSparseVector,
 } from "../qdrant-client.js";
-import { PKB_TARGET_TYPE, type PkbSearchResult } from "./types.js";
+import { getQdrantClient } from "../qdrant-client.js";
+import type { PkbSearchResult } from "./types.js";
+import { PKB_TARGET_TYPE } from "./types.js";
 
 const log = getLogger("pkb-search");
 
@@ -28,9 +29,10 @@ const log = getLogger("pkb-search");
  *
  * PKB files are chunked at index time, so a single path can match on
  * multiple chunks. Scores collapse to the highest per path, per query.
- * The two queries are unioned by path — a path present in only one
- * response still surfaces, with the missing score left `undefined` on
- * its result.
+ * Only paths with a dense cosine score are returned (hybrid-only matches
+ * are dropped because their implicit `denseScore = 0` can never satisfy a
+ * caller's threshold, and keeping them would evict dense-qualifying hits
+ * from the pre-slice top-`limit` window).
  */
 export async function searchPkbFiles(
   queryVector: number[],
@@ -77,30 +79,55 @@ export async function searchPkbFiles(
       )
     : Promise.resolve([]);
 
-  const [denseResults, hybridResults] = await Promise.all([
-    densePromise,
-    hybridPromise,
-  ]);
+  // Silence any hybrid rejection so a short-circuit on dense failure below
+  // does not surface it as an unhandledRejection. We still `await` the
+  // original promise in the non-short-circuit path to observe its outcome.
+  hybridPromise.catch(() => {});
+
+  // Dense is the required signal — only paths with a dense cosine score are
+  // merged, so a dense rejection guarantees `[]` regardless of hybrid. Return
+  // immediately rather than blocking on hybrid latency.
+  let denseResults: QdrantSearchResult[];
+  try {
+    denseResults = await densePromise;
+  } catch (err) {
+    log.warn({ err }, "Dense PKB search failed; returning empty results");
+    return [];
+  }
+
+  let hybridResults: QdrantSearchResult[] = [];
+  if (useHybrid) {
+    try {
+      hybridResults = await hybridPromise;
+    } catch (err) {
+      log.warn(
+        { err },
+        "Hybrid PKB search failed; falling back to dense-only results",
+      );
+    }
+  }
 
   const denseByPath = collapseByPath(denseResults);
   const hybridByPath = useHybrid ? collapseByPath(hybridResults) : new Map();
 
-  const allPaths = new Set<string>([
-    ...denseByPath.keys(),
-    ...hybridByPath.keys(),
-  ]);
-
+  // Only surface paths that have a dense cosine score. Hybrid-only hits
+  // (paths that appeared in the hybrid query but fell outside the dense
+  // prefetch) would have `denseScore = 0`, which is guaranteed to fail any
+  // caller's cosine threshold — and because they'd sort ahead of dense
+  // matches (hybrid-first ranking), they'd evict dense-qualifying hits from
+  // the top-`limit` window before callers ever get a chance to gate on
+  // denseScore. Dropping them keeps gating meaningful with the pre-slice.
   const merged: PkbSearchResult[] = [];
-  for (const path of allPaths) {
-    const denseScore = denseByPath.get(path);
-    const hybridScore = hybridByPath.get(path);
-    // A path that only shows up in the hybrid query (past the dense prefetch
-    // limit) has no cosine score to gate on. Carry denseScore = 0 so callers
-    // see it but can filter it out with their threshold.
+  for (const [path, denseMatch] of denseByPath) {
+    const hybridMatch = hybridByPath.get(path);
+    const snippet = hybridMatch?.snippet ?? denseMatch.snippet;
     merged.push({
       path,
-      denseScore: denseScore ?? 0,
-      ...(useHybrid && hybridScore !== undefined ? { hybridScore } : {}),
+      denseScore: denseMatch.score,
+      ...(useHybrid && hybridMatch !== undefined
+        ? { hybridScore: hybridMatch.score }
+        : {}),
+      ...(snippet !== undefined ? { snippet } : {}),
     });
   }
 
@@ -121,16 +148,24 @@ export async function searchPkbFiles(
   return merged.slice(0, limit);
 }
 
+interface CollapsedPkbMatch {
+  score: number;
+  snippet?: string;
+}
+
 /** Collapse chunk-level Qdrant hits to one score per payload.path (max). */
-function collapseByPath(results: QdrantSearchResult[]): Map<string, number> {
-  const best = new Map<string, number>();
+function collapseByPath(
+  results: QdrantSearchResult[],
+): Map<string, CollapsedPkbMatch> {
+  const best = new Map<string, CollapsedPkbMatch>();
   for (const r of results) {
-    const payload = r.payload as unknown as { path?: unknown };
+    const payload = r.payload as unknown as { path?: unknown; text?: unknown };
     const path = typeof payload.path === "string" ? payload.path : undefined;
     if (!path) continue;
+    const snippet = typeof payload.text === "string" ? payload.text : undefined;
     const existing = best.get(path);
-    if (existing === undefined || r.score > existing) {
-      best.set(path, r.score);
+    if (existing === undefined || r.score > existing.score) {
+      best.set(path, { score: r.score, ...(snippet ? { snippet } : {}) });
     }
   }
   return best;

package/src/memory/published-pages-store.ts

@@ -7,7 +7,7 @@
 
 import { and, eq } from "drizzle-orm";
 
-import { getDb } from "./db.js";
+import { getDb } from "./db-connection.js";
 import { publishedPages } from "./schema.js";
 
 export interface PublishedPageRecord {

package/src/memory/qdrant-client.test.ts

@@ -0,0 +1,60 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+
+import { applyNestedDefaults } from "../config/loader.js";
+import type { AssistantConfig } from "../config/types.js";
+import { resolveQdrantUrl } from "./qdrant-client.js";
+
+const DEFAULT_CONFIG: AssistantConfig = applyNestedDefaults({});
+
+describe("resolveQdrantUrl", () => {
+  const savedPort = process.env.QDRANT_HTTP_PORT;
+  const savedUrl = process.env.QDRANT_URL;
+
+  beforeEach(() => {
+    delete process.env.QDRANT_HTTP_PORT;
+    delete process.env.QDRANT_URL;
+  });
+
+  afterEach(() => {
+    if (savedPort === undefined) delete process.env.QDRANT_HTTP_PORT;
+    else process.env.QDRANT_HTTP_PORT = savedPort;
+    if (savedUrl === undefined) delete process.env.QDRANT_URL;
+    else process.env.QDRANT_URL = savedUrl;
+  });
+
+  test("falls back to config when no env vars are set", () => {
+    expect(resolveQdrantUrl(DEFAULT_CONFIG)).toBe("http://127.0.0.1:6333");
+  });
+
+  test("honours QDRANT_URL when set", () => {
+    process.env.QDRANT_URL = "http://qdrant.example.com:6333";
+    expect(resolveQdrantUrl(DEFAULT_CONFIG)).toBe(
+      "http://qdrant.example.com:6333",
+    );
+  });
+
+  test("QDRANT_HTTP_PORT wins over QDRANT_URL", () => {
+    process.env.QDRANT_URL = "http://qdrant.example.com:6333";
+    process.env.QDRANT_HTTP_PORT = "20200";
+    expect(resolveQdrantUrl(DEFAULT_CONFIG)).toBe("http://127.0.0.1:20200");
+  });
+
+  test("QDRANT_HTTP_PORT wins over config default", () => {
+    process.env.QDRANT_HTTP_PORT = "20200";
+    expect(resolveQdrantUrl(DEFAULT_CONFIG)).toBe("http://127.0.0.1:20200");
+  });
+
+  test("respects a non-default config URL when no env is set", () => {
+    const config: AssistantConfig = {
+      ...DEFAULT_CONFIG,
+      memory: {
+        ...DEFAULT_CONFIG.memory,
+        qdrant: {
+          ...DEFAULT_CONFIG.memory.qdrant,
+          url: "http://custom-host:9999",
+        },
+      },
+    };
+    expect(resolveQdrantUrl(config)).toBe("http://custom-host:9999");
+  });
+});

package/src/memory/qdrant-client.ts

@@ -1,10 +1,35 @@
 import { QdrantClient as QdrantRestClient } from "@qdrant/js-client-rest";
 import { v4 as uuid } from "uuid";
 
+import { getQdrantHttpPortEnv, getQdrantUrlEnv } from "../config/env.js";
+import type { AssistantConfig } from "../config/types.js";
 import { getLogger } from "../util/logger.js";
 
 const log = getLogger("qdrant-client");
 
+/**
+ * Resolve the Qdrant base URL for this process.
+ *
+ * Precedence (highest first):
+ *   1. `QDRANT_HTTP_PORT` — a locally-spawned Qdrant sidecar on 127.0.0.1:<port>.
+ *      Set by the CLI when spawning the daemon with a non-default port
+ *      (multi-local instances).
+ *   2. `QDRANT_URL` — an external Qdrant instance (K8s sidecar, remote URL).
+ *   3. `config.memory.qdrant.url` — static config (defaults to
+ *      `http://127.0.0.1:6333`).
+ *
+ * Every caller that constructs a Qdrant URL should route through this helper
+ * so the precedence stays consistent across the daemon, CLI, and any
+ * background jobs that re-read the config.
+ */
+export function resolveQdrantUrl(config: AssistantConfig): string {
+  const port = getQdrantHttpPortEnv();
+  if (port) return `http://127.0.0.1:${port}`;
+  const url = getQdrantUrlEnv();
+  if (url) return url;
+  return config.memory.qdrant.url;
+}
+
 export interface QdrantSparseVector {
   indices: number[];
   values: number[];

package/src/memory/schema/acp.ts

@@ -0,0 +1,30 @@
+import { index, integer, sqliteTable, text } from "drizzle-orm/sqlite-core";
+
+/**
+ * ACP (Agent Client Protocol) session history. Persists completed ACP
+ * sessions so the sessions UI has data across daemon restarts.
+ *
+ * Created by migration 230. Rows are written when a session reaches a
+ * terminal state (completed, failed, cancelled).
+ */
+export const acpSessionHistory = sqliteTable(
+  "acp_session_history",
+  {
+    id: text("id").primaryKey(),
+    agentId: text("agent_id").notNull(),
+    acpSessionId: text("acp_session_id").notNull(),
+    parentConversationId: text("parent_conversation_id").notNull(),
+    startedAt: integer("started_at").notNull(),
+    completedAt: integer("completed_at"),
+    status: text("status").notNull(),
+    stopReason: text("stop_reason"),
+    error: text("error"),
+    eventLogJson: text("event_log_json").notNull().default("[]"),
+  },
+  (table) => [
+    index("idx_acp_session_history_started_at").on(table.startedAt),
+    index("idx_acp_session_history_parent_conversation_id").on(
+      table.parentConversationId,
+    ),
+  ],
+);

package/src/memory/schema/conversations.ts

@@ -28,11 +28,11 @@ export const conversations = sqliteTable(
     originInterface: text("origin_interface"),
     forkParentConversationId: text("fork_parent_conversation_id"),
     forkParentMessageId: text("fork_parent_message_id"),
-    hostAccess: integer("host_access").notNull().default(0),
     isAutoTitle: integer("is_auto_title").notNull().default(1),
     scheduleJobId: text("schedule_job_id"),
     lastMessageAt: integer("last_message_at"),
     archivedAt: integer("archived_at"),
+    inferenceProfile: text("inference_profile"),
   },
   (table) => [
     index("idx_conversations_updated_at").on(table.updatedAt),

package/src/memory/schema/index.ts

@@ -1,3 +1,4 @@
+export * from "./acp.js";
 export * from "./calls.js";
 export * from "./contacts.js";
 export * from "./conversations.js";

package/src/memory/schema/infrastructure.ts

@@ -28,6 +28,8 @@ export const cronJobs = sqliteTable("cron_jobs", {
   reuseConversation: integer("reuse_conversation", { mode: "boolean" })
     .notNull()
     .default(false), // reuse the same conversation across runs
+  script: text("script"), // shell command for script mode (nullable, only used when mode = 'script')
+  wakeConversationId: text("wake_conversation_id"), // target conversation for wake mode (nullable)
   createdAt: integer("created_at").notNull(),
   updatedAt: integer("updated_at").notNull(),
 });
@@ -190,19 +192,6 @@ export const lifecycleEvents = sqliteTable("lifecycle_events", {
   createdAt: integer("created_at").notNull(),
 });
 
-export const actorTokenRecords = sqliteTable("actor_token_records", {
-  id: text("id").primaryKey(),
-  tokenHash: text("token_hash").notNull(),
-  guardianPrincipalId: text("guardian_principal_id").notNull(),
-  hashedDeviceId: text("hashed_device_id").notNull(),
-  platform: text("platform").notNull(),
-  status: text("status").notNull().default("active"),
-  issuedAt: integer("issued_at").notNull(),
-  expiresAt: integer("expires_at"),
-  createdAt: integer("created_at").notNull(),
-  updatedAt: integer("updated_at").notNull(),
-});
-
 export const traceEvents = sqliteTable(
   "trace_events",
   {
@@ -225,22 +214,3 @@ export const traceEvents = sqliteTable(
     ),
   ],
 );
-
-export const actorRefreshTokenRecords = sqliteTable(
-  "actor_refresh_token_records",
-  {
-    id: text("id").primaryKey(),
-    tokenHash: text("token_hash").notNull(),
-    familyId: text("family_id").notNull(),
-    guardianPrincipalId: text("guardian_principal_id").notNull(),
-    hashedDeviceId: text("hashed_device_id").notNull(),
-    platform: text("platform").notNull(),
-    status: text("status").notNull().default("active"),
-    issuedAt: integer("issued_at").notNull(),
-    absoluteExpiresAt: integer("absolute_expires_at").notNull(),
-    inactivityExpiresAt: integer("inactivity_expires_at").notNull(),
-    lastUsedAt: integer("last_used_at"),
-    createdAt: integer("created_at").notNull(),
-    updatedAt: integer("updated_at").notNull(),
-  },
-);

package/src/memory/schema/memory-graph.ts

@@ -138,17 +138,39 @@ export const memoryGraphTriggers = sqliteTable(
   ],
 );
 
-export const memoryGraphNodeEdits = sqliteTable(
-  "memory_graph_node_edits",
-  {
-    id: text("id").primaryKey(),
-    nodeId: text("node_id")
-      .notNull()
-      .references(() => memoryGraphNodes.id, { onDelete: "cascade" }),
-    previousContent: text("previous_content").notNull(),
-    newContent: text("new_content").notNull(),
-    source: text("source").notNull(),
-    conversationId: text("conversation_id"),
-    created: integer("created").notNull(),
-  },
-);
+export const memoryGraphNodeEdits = sqliteTable("memory_graph_node_edits", {
+  id: text("id").primaryKey(),
+  nodeId: text("node_id")
+    .notNull()
+    .references(() => memoryGraphNodes.id, { onDelete: "cascade" }),
+  previousContent: text("previous_content").notNull(),
+  newContent: text("new_content").notNull(),
+  source: text("source").notNull(),
+  conversationId: text("conversation_id"),
+  created: integer("created").notNull(),
+});
+
+// ---------------------------------------------------------------------------
+// Memory v2 — activation_state
+// ---------------------------------------------------------------------------
+
+/**
+ * Per-conversation snapshot of the v2 retrieval state. One row per
+ * conversation; created lazily on first injection.
+ *
+ * - `stateJson`: sparse `{slug: activation}` map (only slugs > epsilon).
+ * - `everInjectedJson`: append-only `[{slug, turn}]` list used to keep
+ *   per-turn injections strictly delta-only. Pruned when compaction evicts
+ *   the turns whose attached slugs lived on.
+ *
+ * No FK to conversations.id — fork() may copy state for a child
+ * conversation that hasn't been persisted yet, and stale rows are cheap.
+ */
+export const activationState = sqliteTable("activation_state", {
+  conversationId: text("conversation_id").primaryKey(),
+  messageId: text("message_id").notNull(),
+  stateJson: text("state_json").notNull(),
+  everInjectedJson: text("ever_injected_json").notNull().default("[]"),
+  currentTurn: integer("current_turn").notNull().default(0),
+  updatedAt: integer("updated_at").notNull(),
+});

package/src/memory/schema/oauth.ts

@@ -20,7 +20,7 @@ export const oauthProviders = sqliteTable("oauth_providers", {
   userinfoUrl: text("userinfo_url"),
   baseUrl: text("base_url"),
   defaultScopes: text("default_scopes").notNull().default("[]"),
-  scopePolicy: text("scope_policy").notNull().default("{}"),
+  availableScopes: text("available_scopes"),
   scopeSeparator: text("scope_separator").notNull().default(" "),
   authorizeParams: text("extra_params"),
   pingUrl: text("ping_url"),
@@ -30,6 +30,9 @@ export const oauthProviders = sqliteTable("oauth_providers", {
   revokeUrl: text("revoke_url"),
   revokeBodyTemplate: text("revoke_body_template"),
   managedServiceConfigKey: text("managed_service_config_key"),
+  managedServiceIsPaid: integer("managed_service_is_paid", { mode: "boolean" })
+    .notNull()
+    .default(false),
   displayLabel: text("display_name"),
   description: text("description"),
   dashboardUrl: text("dashboard_url"),

package/src/memory/scoped-approval-grants.ts

@@ -15,7 +15,8 @@ import { and, eq, sql } from "drizzle-orm";
 import { v4 as uuid } from "uuid";
 
 import { getLogger } from "../util/logger.js";
-import { getDb, rawChanges } from "./db.js";
+import { getDb } from "./db-connection.js";
+import { rawChanges } from "./raw-query.js";
 import { scopedApprovalGrants } from "./schema.js";
 
 const log = getLogger("scoped-approval-grants");

package/src/memory/search/semantic.ts

@@ -1,7 +1,7 @@
 import { inArray } from "drizzle-orm";
 
 import { getLogger } from "../../util/logger.js";
-import { getDb } from "../db.js";
+import { getDb } from "../db-connection.js";
 import { withQdrantBreaker } from "../qdrant-circuit-breaker.js";
 import type {
   QdrantSearchResult,
@@ -295,7 +295,7 @@ function buildHybridFilter(
   };
 }
 
-export function mapCosineToUnit(value: number): number {
+function mapCosineToUnit(value: number): number {
   return Math.max(0, Math.min(1, (value + 1) / 2));
 }