@vellumai/assistant 0.7.1 → 0.7.3

package/src/memory/v2/skill-store.ts

@@ -2,18 +2,22 @@
 // Memory v2 — Skill catalog → embedded skill entries
 // ---------------------------------------------------------------------------
 //
-// Mirrors v1's `seedSkillGraphNodes` + `seedUninstalledCatalogSkillMemories`
-// (capability-seed.ts) for the v2 pipeline: enumerate the enabled-skill
-// catalog AND uninstalled catalog skills, render each skill's prose statement
-// via `buildSkillContent`, embed dense + sparse, upsert into the dedicated
-// `memory_v2_skills` Qdrant collection, and prune stale points from prior
-// catalog state. Including uninstalled catalog skills ensures their activation
-// hints are discoverable by intent so the model can auto-install them.
+// Enumerate the enabled-skill catalog AND uninstalled catalog skills, render
+// each skill's prose statement via `buildSkillContent`, embed dense + sparse,
+// and upsert into `memory_v2_concept_pages` under the slug `skills/<id>`.
+// Including uninstalled catalog skills ensures their activation hints are
+// discoverable by intent so the model can auto-install them.
 //
-// Unlike v1, skill entries are kept in a small in-process cache so the render
-// path can fetch a `SkillEntry` synchronously by id without round-tripping to
-// Qdrant. The cache is replaced atomically at the end of a successful seed
-// run; on error the prior cache stays intact (skills are best-effort).
+// Skills share the concept-page collection rather than living in a dedicated
+// one so the per-turn activation pipeline scores them against the same
+// candidate ANN as concept pages, with the same decay and spread machinery.
+// The render path branches on the `skills/` slug prefix to surface them as
+// the `### Skills You Can Use` subsection.
+//
+// Skill entries are kept in a small in-process cache so the render path can
+// fetch a `SkillEntry` synchronously by id without round-tripping to Qdrant.
+// The cache is replaced atomically at the end of a successful seed run; on
+// error the prior cache stays intact (skills are best-effort).
 
 import { isAssistantFeatureFlagEnabled } from "../../config/assistant-feature-flags.js";
 import { getConfig } from "../../config/loader.js";
@@ -25,19 +29,36 @@ import {
   fromSkillSummary,
 } from "../../skills/skill-memory.js";
 import { getLogger } from "../../util/logger.js";
+import { applyCorrectionIfCalibrated } from "../anisotropy.js";
 import {
   embedWithBackend,
   generateSparseEmbedding,
 } from "../embedding-backend.js";
+import {
+  pruneSlugsWithPrefixExcept,
+  upsertConceptPageEmbedding,
+} from "./qdrant.js";
 import {
   augmentMcpSetupDescription,
   buildSkillContent,
 } from "./skill-content.js";
-import { pruneSkillsExcept, upsertSkillEmbedding } from "./skill-qdrant.js";
 import type { SkillEntry } from "./types.js";
 
 const log = getLogger("memory-v2-skill-store");
 
+/**
+ * Slug prefix under which skill embeddings are indexed in
+ * `memory_v2_concept_pages`. Concept-page slugs must match
+ * `[a-z0-9][a-z0-9-]*(/...)*`, and `skills` matches that pattern, so the
+ * prefix coexists with hand-authored concept pages without escape work.
+ */
+export const SKILL_SLUG_PREFIX = "skills/";
+
+/** Compose the unified-collection slug for a skill id. */
+export function skillSlugFor(id: string): string {
+  return `${SKILL_SLUG_PREFIX}${id}`;
+}
+
 /**
  * Module-level cache of rendered skill entries keyed by skill id. `null` until
  * the first successful seed run completes; replaced atomically on each
@@ -46,30 +67,27 @@ const log = getLogger("memory-v2-skill-store");
 let entries: Map<string, SkillEntry> | null = null;
 
 /**
- * Seed (or re-seed) the v2 skill embedding collection from the live skill
- * catalog. Idempotent: safe to call repeatedly. Best-effort: never throws —
- * any failure leaves the prior `entries` cache in place and logs a warning.
+ * Seed (or re-seed) skill embeddings into the unified concept-page collection.
+ * Idempotent: safe to call repeatedly. Best-effort: never throws — any
+ * failure leaves the prior `entries` cache in place and logs a warning.
  *
  * Steps:
- *   1. Enumerate the local skill catalog and resolve each skill's enabled state
- *      (`resolveSkillStates`).
- *   2. Build a `SkillCapabilityInput` per enabled skill, applying the
- *      mcp-setup augmentation (mirrors v1) and the prose-style content render
- *      (`buildSkillContent`, capped at 500 chars).
+ *   1. Enumerate the local skill catalog and resolve each skill's enabled
+ *      state (`resolveSkillStates`).
+ *   2. Build a `SkillEntry` per enabled skill, applying the mcp-setup
+ *      augmentation and the prose-style content render (`buildSkillContent`,
+ *      capped at 500 chars).
  *   3. Defense-in-depth feature-flag filter: drop any skill whose declared
- *      `metadata.vellum.feature-flag` is currently disabled. `resolveSkillStates`
- *      already enforces this, but we mirror v1's enforcement point so the v2
- *      collection never holds an embedding for a flag-gated skill if the two
- *      ever drift.
- *   3b. Fetch the full remote catalog and seed any uninstalled skills so their
- *      activation hints are discoverable by semantic search. Best-effort: if
- *      the catalog fetch fails, only installed skills are seeded.
+ *      `metadata.vellum.feature-flag` is currently disabled.
+ *   3b. Fetch the full remote catalog and seed any uninstalled skills so
+ *      their activation hints are discoverable by semantic search. Best-effort:
+ *      if the catalog fetch fails, only installed skills are seeded.
  *   4. Embed all `content` strings in a single dense `embedWithBackend` call,
  *      and a per-skill synchronous `generateSparseEmbedding`.
- *   5. Upsert one Qdrant point per skill via `upsertSkillEmbedding` (keyed
- *      deterministically on id so re-runs replace in place).
- *   6. Call `pruneSkillsExcept` with the active id list to drop any stale
- *      points from prior catalog state (e.g. uninstalled skills).
+ *   5. Upsert one Qdrant point per skill via `upsertConceptPageEmbedding`
+ *      keyed deterministically on slug `skills/<id>`.
+ *   6. Call `pruneSlugsWithPrefixExcept(SKILL_SLUG_PREFIX, ...)` to drop any
+ *      stale points from prior catalog state (e.g. uninstalled skills).
  *   7. Replace the module-level `entries` cache with the freshly built map.
  */
 export async function seedV2SkillEntries(): Promise<void> {
@@ -82,8 +100,7 @@ export async function seedV2SkillEntries(): Promise<void> {
     // Track every locally-installed skill id (regardless of enabled/disabled
     // state) so the catalog-seeding loop below treats them all as "installed"
     // and never re-seeds a disabled skill from `getCatalog()` as if it were
-    // uninstalled. Mirrors v1's `seedUninstalledCatalogSkillMemories`, which
-    // keys off `loadSkillCatalog()` (the installed set) for the same reason.
+    // uninstalled.
     const installedIds = new Set<string>(catalog.map((s) => s.id));
 
     // Build the input list, applying the mcp-setup description augmentation
@@ -99,8 +116,8 @@ export async function seedV2SkillEntries(): Promise<void> {
     }
 
     // Seed uninstalled catalog skills so their activation hints are
-    // discoverable by intent (mirrors v1's seedUninstalledCatalogSkillMemories).
-    // Track whether the catalog was available so we can guard pruning below.
+    // discoverable by intent. Track whether the catalog was available so we
+    // can guard pruning below.
     let catalogAvailable = false;
     try {
       const fullCatalog = await getCatalog();
@@ -122,31 +139,41 @@ export async function seedV2SkillEntries(): Promise<void> {
 
     // Embed all content strings in one batched call. Sparse vectors are
     // computed in-process (no network).
-    const { vectors: denseVectors } = await embedWithBackend(
+    const embedded = await embedWithBackend(
       config,
       seeds.map((s) => s.content),
     );
+    const denseVectors = await Promise.all(
+      embedded.vectors.map((v) =>
+        applyCorrectionIfCalibrated(v, embedded.provider, embedded.model),
+      ),
+    );
 
     const now = Date.now();
     const nextEntries = new Map<string, SkillEntry>();
-    for (let i = 0; i < seeds.length; i++) {
-      const seed = seeds[i];
-      await upsertSkillEmbedding({
-        ...seed,
-        dense: denseVectors[i],
-        sparse: generateSparseEmbedding(seed.content),
-        updatedAt: now,
-      });
+    await Promise.all(
+      seeds.map((seed, i) =>
+        upsertConceptPageEmbedding({
+          slug: skillSlugFor(seed.id),
+          dense: denseVectors[i],
+          sparse: generateSparseEmbedding(seed.content),
+          updatedAt: now,
+        }),
+      ),
+    );
+    for (const seed of seeds) {
       nextEntries.set(seed.id, seed);
     }
 
-    // Prune stale points. When the catalog is unavailable (empty array from
-    // network failure or cold cache), we cannot enumerate which uninstalled
-    // catalog skills should exist, so skip pruning entirely to avoid
-    // aggressively removing previously-seeded catalog skill embeddings.
-    // Mirrors v1's safeguard in capability-seed.ts (lines 124–143).
+    // Prune stale skill slugs. When the catalog is unavailable (empty array
+    // from network failure or cold cache), we cannot enumerate which
+    // uninstalled catalog skills should exist, so skip pruning entirely to
+    // avoid aggressively removing previously-seeded catalog skill embeddings.
     if (catalogAvailable) {
-      await pruneSkillsExcept(seeds.map((s) => s.id));
+      await pruneSlugsWithPrefixExcept(
+        SKILL_SLUG_PREFIX,
+        seeds.map((s) => s.id),
+      );
     } else {
       log.info(
         "Catalog unavailable — skipping skill pruning to preserve prior catalog embeddings",
@@ -163,13 +190,24 @@ export async function seedV2SkillEntries(): Promise<void> {
 /**
  * Synchronous lookup of a previously-seeded `SkillEntry` by skill id. Returns
  * `null` when the cache has not yet been populated, when the id is unknown,
- * or when a prior seed run dropped the id (e.g. the skill was disabled). Used
- * by the render path to attach skill-related content to outgoing prompts.
+ * or when a prior seed run dropped the id (e.g. the skill was disabled).
+ *
+ * Accepts either a bare skill id (`example-skill`) or its unified-collection
+ * slug (`skills/example-skill`) so render-side callers can pass through what
+ * they have without a manual prefix strip.
  */
-export function getSkillCapability(id: string): SkillEntry | null {
+export function getSkillCapability(idOrSlug: string): SkillEntry | null {
+  const id = idOrSlug.startsWith(SKILL_SLUG_PREFIX)
+    ? idOrSlug.slice(SKILL_SLUG_PREFIX.length)
+    : idOrSlug;
   return entries?.get(id) ?? null;
 }
 
+/** True iff the slug refers to a skill entry in the unified collection. */
+export function isSkillSlug(slug: string): boolean {
+  return slug.startsWith(SKILL_SLUG_PREFIX);
+}
+
 /** @internal Test-only: clear the module-level cache. */
 export function _resetSkillStoreForTests(): void {
   entries = null;

package/src/memory/v2/sparse-bm25.ts

@@ -0,0 +1,245 @@
+// ---------------------------------------------------------------------------
+// Memory v2 — BM25 sparse channel
+// ---------------------------------------------------------------------------
+//
+// Replaces the legacy TF-only sparse embedding (`generateSparseEmbedding` in
+// `../embedding-backend.ts`) with a real Okapi BM25 implementation. Common
+// words like "i", "am", "the" no longer dominate sparse matching the way they
+// did when every token was weighted equally.
+//
+// BM25 score for document `d` and query `q`:
+//
+//   score(d, q) = Σ_t∈q  IDF(t) · TF_sat(d, t)
+//   TF_sat(d, t) = tf(d, t) · (k1 + 1)
+//                / (tf(d, t) + k1 · (1 - b + b · |d| / avg_dl))
+//   IDF(t)       = log( (N - df(t) + 0.5) / (df(t) + 0.5) + 1 )
+//
+// `+1` inside the IDF log keeps the result non-negative even when df(t) > N/2,
+// matching the variant Lucene uses for `BM25Similarity`.
+//
+// **Asymmetric encoding**: documents carry the full BM25 weight per token
+// (IDF · TF_sat baked into the stored vector), and queries carry binary
+// occurrence per token. Qdrant's sparse dot product then reduces to the BM25
+// score directly. Putting BM25 on the doc side means the weights need
+// recomputing whenever the corpus DF or avg_dl changes — operators trigger
+// that with `assistant memory v2 reembed` after major content shifts.
+
+import { readFile } from "node:fs/promises";
+
+import type { SparseEmbedding } from "../embedding-types.js";
+import {
+  SPARSE_VOCAB_SIZE,
+  tokenHash,
+  tokenizeStemmed,
+} from "../sparse-tokenize.js";
+import { listPages } from "./page-store.js";
+
+/**
+ * Aggregate corpus statistics used to weight a BM25 document vector. Held in
+ * memory after a startup walk over `memory/concepts/`.
+ */
+export interface CorpusStats {
+  /** Total document count over which DF was accumulated. */
+  totalDocs: number;
+  /** hashedTokenIndex (in `[0, SPARSE_VOCAB_SIZE)`) → distinct-doc count. */
+  df: Map<number, number>;
+  /** Average document length in tokens, post-tokenize. */
+  avgDl: number;
+  /** Wall-clock millis at build time — used by diagnostics, not the formula. */
+  builtAt: number;
+}
+
+/** BM25 hyperparameters. Standard Lucene/Elasticsearch defaults. */
+export interface Bm25Params {
+  /** TF saturation curve. ~1.2 is standard. */
+  k1: number;
+  /** Length normalization. 0 = none, 1 = full. ~0.75 is standard. */
+  b: number;
+}
+
+let _conceptPageStats: CorpusStats | null = null;
+
+/**
+ * Latest in-memory corpus stats for `memory/concepts/`, or `null` if a build
+ * has not yet completed. Callers must handle `null` and fall back to legacy
+ * TF-only behavior so the daemon remains usable during the brief startup
+ * window before {@link rebuildConceptPageCorpusStats} finishes.
+ */
+export function getConceptPageCorpusStats(): CorpusStats | null {
+  return _conceptPageStats;
+}
+
+/**
+ * Walk every concept page on disk, accumulate document frequency per hashed
+ * token bucket, and average document length. Atomically swaps the result into
+ * the module-level cache when the walk succeeds. On error the previous stats
+ * stay live.
+ *
+ * Reads bodies via `readPage`-equivalent direct file reads to avoid paying for
+ * frontmatter parsing on every page (we only need the body for sparse).
+ */
+export async function rebuildConceptPageCorpusStats(
+  workspaceDir: string,
+): Promise<void> {
+  const slugs = await listPages(workspaceDir);
+  if (slugs.length === 0) {
+    _conceptPageStats = {
+      totalDocs: 0,
+      df: new Map(),
+      avgDl: 0,
+      builtAt: Date.now(),
+    };
+    return;
+  }
+
+  const df = new Map<number, number>();
+  let totalTokens = 0;
+  let docsCounted = 0;
+
+  for (const slug of slugs) {
+    const body = await readPageBodyForStats(workspaceDir, slug);
+    if (body === null) continue;
+    const tokens = tokenizeStemmed(body);
+    if (tokens.length === 0) continue;
+    totalTokens += tokens.length;
+    docsCounted += 1;
+    const seen = new Set<number>();
+    for (const token of tokens) {
+      const idx = tokenHash(token, SPARSE_VOCAB_SIZE);
+      if (seen.has(idx)) continue;
+      seen.add(idx);
+      df.set(idx, (df.get(idx) ?? 0) + 1);
+    }
+  }
+
+  _conceptPageStats = {
+    totalDocs: docsCounted,
+    df,
+    avgDl: docsCounted > 0 ? totalTokens / docsCounted : 0,
+    builtAt: Date.now(),
+  };
+}
+
+/**
+ * Read just the body of a page for stats accumulation. Skips the YAML
+ * frontmatter without invoking the schema-validating `readPage` parser, since
+ * any parse failure surfaced there would abort the whole rebuild — and we
+ * only need the prose half for tokenization.
+ */
+async function readPageBodyForStats(
+  workspaceDir: string,
+  slug: string,
+): Promise<string | null> {
+  const path = `${workspaceDir}/memory/concepts/${slug}.md`;
+  let raw: string;
+  try {
+    raw = await readFile(path, "utf-8");
+  } catch {
+    return null;
+  }
+  // Strip a leading `---\n...\n---\n` block if present; otherwise return raw.
+  if (raw.startsWith("---")) {
+    const closing = raw.indexOf("\n---", 3);
+    if (closing !== -1) {
+      const after = raw.indexOf("\n", closing + 4);
+      if (after !== -1) return raw.slice(after + 1);
+    }
+  }
+  return raw;
+}
+
+/**
+ * Compute the BM25 IDF weight for a hashed token bucket. Returns `0` when the
+ * token's df equals the corpus size (a token in every document carries no
+ * discriminating power).
+ */
+function computeIdf(stats: CorpusStats, hashIdx: number): number {
+  const df = stats.df.get(hashIdx) ?? 0;
+  const numerator = stats.totalDocs - df + 0.5;
+  const denominator = df + 0.5;
+  return Math.log(numerator / denominator + 1);
+}
+
+/**
+ * Document-side BM25-weighted sparse vector. Each emitted value is
+ * `IDF(t) · TF_sat(d, t)` so the dot product against a binary query vector
+ * (see {@link generateBm25QueryEmbedding}) yields the BM25 score.
+ *
+ * Returns an empty embedding for empty input or when the corpus is empty
+ * (every IDF would be zero anyway).
+ */
+export function generateBm25DocEmbedding(
+  text: string,
+  stats: CorpusStats,
+  params: Bm25Params,
+): SparseEmbedding {
+  const tokens = tokenizeStemmed(text);
+  if (tokens.length === 0 || stats.totalDocs === 0) {
+    return { indices: [], values: [] };
+  }
+
+  // Per-document term frequencies, keyed by hashed bucket.
+  const tf = new Map<number, number>();
+  for (const token of tokens) {
+    const idx = tokenHash(token, SPARSE_VOCAB_SIZE);
+    tf.set(idx, (tf.get(idx) ?? 0) + 1);
+  }
+
+  const docLen = tokens.length;
+  // avg_dl can be 0 only when totalDocs is 0, which we already short-circuited.
+  const lengthFactor = 1 - params.b + (params.b * docLen) / stats.avgDl;
+  const indices: number[] = [];
+  const values: number[] = [];
+
+  for (const [idx, freq] of tf) {
+    const idf = computeIdf(stats, idx);
+    if (idf === 0) continue; // Skip tokens that contribute nothing to scores.
+    const saturated =
+      (freq * (params.k1 + 1)) / (freq + params.k1 * lengthFactor);
+    const weight = idf * saturated;
+    if (weight === 0) continue;
+    indices.push(idx);
+    values.push(weight);
+  }
+
+  return { indices, values };
+}
+
+/**
+ * Query-side sparse vector — binary occurrence per distinct query token. The
+ * dot product `Σ_t v_q(t) · v_d(t)` against a BM25-weighted document vector
+ * is exactly the BM25 score, since `v_q(t) = 1` for tokens in the query and
+ * `0` otherwise.
+ *
+ * Stateless — does not need corpus stats, so callers can use this on every
+ * turn without coordinating with {@link rebuildConceptPageCorpusStats}.
+ */
+export function generateBm25QueryEmbedding(text: string): SparseEmbedding {
+  const tokens = tokenizeStemmed(text);
+  if (tokens.length === 0) {
+    return { indices: [], values: [] };
+  }
+
+  const seen = new Set<number>();
+  const indices: number[] = [];
+  const values: number[] = [];
+  for (const token of tokens) {
+    const idx = tokenHash(token, SPARSE_VOCAB_SIZE);
+    if (seen.has(idx)) continue;
+    seen.add(idx);
+    indices.push(idx);
+    values.push(1);
+  }
+
+  return { indices, values };
+}
+
+/** @internal Test-only: reset module-level singletons. */
+export function _resetCorpusStatsForTests(): void {
+  _conceptPageStats = null;
+}
+
+/** @internal Test-only: install a fixture stats table without disk I/O. */
+export function _setCorpusStatsForTests(stats: CorpusStats | null): void {
+  _conceptPageStats = stats;
+}

package/src/memory/v2/static-context.ts

@@ -6,16 +6,18 @@
 // and returns a concatenated, header-wrapped block ready to splice into the
 // current user message via the injector chain.
 //
-// Pairs with the v2 per-turn activation block (`prependMemoryV2Block` in
-// `conversation-graph-memory.ts`) — that block carries activated concept
-// pages selected by the activation pipeline; this static block carries the
-// always-relevant aggregate views written by consolidation and the user.
-// Both land on the user message so the system prompt stays cache-stable.
+// Pairs with the v2 per-turn activation block (`maybeRouteV2Injection` in
+// `conversation-graph-memory.ts`, which threads through `injectTextBlock`)
+// — that block carries activated concept pages selected by the activation
+// pipeline; this static block carries the always-relevant aggregate views
+// written by consolidation and the user. Both land on the user message so
+// the system prompt stays cache-stable.
 //
 // Refresh cadence is owned by the caller: the agent loop only passes the
 // content through when `mode === "full"` (first turn / post-compaction),
 // matching the existing PKB auto-inject pattern.
 
+import type { ChannelId } from "../../channels/types.js";
 import { isAssistantFeatureFlagEnabled } from "../../config/assistant-feature-flags.js";
 import { loadConfig } from "../../config/loader.js";
 import { readPromptFile } from "../../prompts/system-prompt.js";
@@ -60,3 +62,24 @@ export function readMemoryV2StaticContent(): string | null {
   }
   return sections.length > 0 ? sections.join("\n\n") : null;
 }
+
+/**
+ * Static memory holds the user's aggregate personal pages
+ * (essentials/threads/recent/buffer). Block injection when a non-guardian
+ * actor reaches the assistant over a remote channel — otherwise the model
+ * can be prompt-injected into reciting private memory. Internal flows
+ * (`sourceChannel: "vellum"`) and turns with no trust context pass through
+ * unchanged; this gate exists only to keep remote untrusted actors out.
+ */
+export function shouldLoadMemoryV2Static(args: {
+  shouldInjectNowAndPkb: boolean;
+  sourceChannel: ChannelId | undefined;
+  isTrustedActor: boolean;
+}): boolean {
+  if (!args.shouldInjectNowAndPkb) return false;
+  const isRemoteUntrustedActor =
+    args.sourceChannel !== undefined &&
+    args.sourceChannel !== "vellum" &&
+    !args.isTrustedActor;
+  return !isRemoteUntrustedActor;
+}

package/src/memory/v2/types.ts

@@ -85,20 +85,20 @@ export const ActivationStateSchema = z.object({
 export type ActivationState = z.infer<typeof ActivationStateSchema>;
 
 // ---------------------------------------------------------------------------
-// Skill autoinjection (synthetic in-memory entries, not on-disk pages)
+// Skill entries (synthetic concept-collection rows, not on-disk pages)
 // ---------------------------------------------------------------------------
 
 /**
- * Per-skill capability snapshot held in-process and embedded into the
- * `memory_v2_skills` Qdrant collection. `content` is the rendered
- * `buildSkillContent` string — already capped at 500 chars upstream and
- * already containing the skill's display name — and is what we embed and
- * what we render verbatim in `### Skills You Can Use`.
+ * Per-skill capability snapshot held in-process and embedded into the unified
+ * `memory_v2_concept_pages` Qdrant collection under the slug `skills/<id>`.
+ * `content` is the rendered `buildSkillContent` string — already capped at
+ * 500 chars upstream and already containing the skill's display name — and
+ * is what we embed and what we render verbatim in `### Skills You Can Use`.
  *
- * Plain interface (no Zod) because skill data does not cross a
- * serialization boundary: it is built in-process by `seedV2SkillEntries`
- * and read in-process by `renderInjectionBlock`. The Qdrant payload is
- * not parsed back through this type.
+ * Plain interface (no Zod) because skill data does not cross a serialization
+ * boundary: it is built in-process by `seedV2SkillEntries` and read in-process
+ * by `renderInjectionBlock`. The Qdrant payload is not parsed back through
+ * this type.
  */
 export interface SkillEntry {
   id: string;

package/src/messaging/providers/gmail/types.ts

@@ -95,52 +95,3 @@ export interface GmailModifyRequest {
 
 /** Message format for GET requests */
 export type GmailMessageFormat = "minimal" | "full" | "raw" | "metadata";
-
-/** Attachment data from the Gmail API */
-export interface GmailAttachment {
-  size: number;
-  data: string; // base64url-encoded
-}
-
-/** Gmail filter criteria */
-export interface GmailFilterCriteria {
-  from?: string;
-  to?: string;
-  subject?: string;
-  query?: string;
-  hasAttachment?: boolean;
-  excludeChats?: boolean;
-  size?: number;
-  sizeComparison?: "larger" | "smaller";
-}
-
-/** Gmail filter action */
-export interface GmailFilterAction {
-  addLabelIds?: string[];
-  removeLabelIds?: string[];
-  forward?: string;
-}
-
-/** Gmail filter */
-export interface GmailFilter {
-  id: string;
-  criteria: GmailFilterCriteria;
-  action: GmailFilterAction;
-}
-
-/** Gmail filters list response */
-export interface GmailFiltersListResponse {
-  filter?: GmailFilter[];
-}
-
-/** Gmail vacation auto-reply settings */
-export interface GmailVacationSettings {
-  enableAutoReply: boolean;
-  responseSubject?: string;
-  responseBodyPlainText?: string;
-  responseBodyHtml?: string;
-  restrictToContacts?: boolean;
-  restrictToDomain?: boolean;
-  startTime?: string; // epoch ms as string
-  endTime?: string; // epoch ms as string
-}

package/src/messaging/providers/slack/adapter.ts

@@ -11,7 +11,6 @@ import {
 } from "@vellumai/slack-text";
 
 import { findContactChannel } from "../../../contacts/contact-store.js";
-import { upsertContactChannel } from "../../../contacts/contacts-write.js";
 import type { OAuthConnection } from "../../../oauth/connection.js";
 import { resolveOAuthConnection } from "../../../oauth/connection-resolver.js";
 import { isProviderConnected } from "../../../oauth/oauth-store.js";
@@ -163,18 +162,6 @@ async function resolveUserName(
       resp.user.real_name ||
       resp.user.name;
     userNameCache.set(userId, name);
-
-    // Persist to contacts for future sessions
-    try {
-      upsertContactChannel({
-        sourceChannel: "slack",
-        externalUserId: userId,
-        displayName: name,
-      });
-    } catch {
-      // Non-fatal — caching failure shouldn't break messaging
-    }
-
     return name;
   } catch {
     return userId;
@@ -433,24 +420,7 @@ export const slackProvider: MessagingProvider = {
         const dmUserId = conv.metadata.dmUserId as string;
         conv.name = await resolveUserName(auth, dmUserId);
 
-        // Persist the DM channel ID so future sends skip conversations.open
-        try {
-          const existing = findContactChannel({
-            channelType: "slack",
-            externalUserId: dmUserId,
-          });
-          if (existing && !existing.channel.externalChatId) {
-            upsertContactChannel({
-              contactId: existing.contact.id,
-              sourceChannel: "slack",
-              externalUserId: dmUserId,
-              externalChatId: conv.id,
-              displayName: conv.name,
-            });
-          }
-        } catch {
-          // Non-fatal
-        }
+
       }
     }