@vellumai/assistant 0.3.4 → 0.3.6

package/src/memory/search/lexical.ts

@@ -1,62 +1,91 @@
 import { and, desc, eq, inArray, notInArray } from 'drizzle-orm';
 import { getLogger } from '../../util/logger.js';
-import { getDb } from '../db.js';
+import { getDb, rawAll } from '../db.js';
 import { memorySegments } from '../schema.js';
 import type { Candidate, CandidateType } from './types.js';
 import { computeRecencyScore } from './ranking.js';
 
 const log = getLogger('memory-retriever');
 
+// Threshold beyond which a raw SQL query is considered slow and logged as a warning.
+const SLOW_QUERY_MS = 2000;
+
+/**
+ * Execute a synchronous raw SQL query with timing. Logs a warning if the
+ * query exceeds SLOW_QUERY_MS. Since bun:sqlite queries are synchronous,
+ * we can't abort them mid-execution, but we can detect and report slowness.
+ */
+function timedRawQuery<T>(label: string, fn: () => T[]): T[] {
+  const start = performance.now();
+  const result = fn();
+  const elapsed = performance.now() - start;
+  if (elapsed >= SLOW_QUERY_MS) {
+    log.warn({ label, elapsedMs: Math.round(elapsed) }, 'Raw SQL query exceeded slow threshold');
+  }
+  return result;
+}
+
+interface FtsRow {
+  segment_id: string;
+  message_id: string;
+  text: string;
+  created_at: number;
+  rank: number;
+}
+
 export function lexicalSearch(query: string, limit: number, excludedMessageIds: string[] = [], scopeIds?: string[]): Candidate[] {
   const trimmed = query.trim();
   if (trimmed.length === 0 || limit <= 0) return [];
   const matchQuery = buildFtsMatchQuery(trimmed);
   if (!matchQuery) return [];
   const excluded = new Set(excludedMessageIds);
-  const db = getDb();
-  const raw = (db as unknown as { $client: { query: (q: string) => { all: (...params: unknown[]) => unknown[] } } }).$client;
-  let rows: Array<{
-    segment_id: string;
-    message_id: string;
-    text: string;
-    created_at: number;
-    rank: number;
-  }> = [];
-  const queryLimit = excluded.size > 0
-    ? Math.max(limit + 24, limit * 2)
-    : limit;
   const scopeClause = scopeIds
     ? ` AND s.scope_id IN (${scopeIds.map(() => '?').join(',')})`
     : '';
-  const params: unknown[] = [matchQuery, ...(scopeIds ?? []), queryLimit];
-  try {
-    rows = raw.query(`
-      SELECT
-        f.segment_id AS segment_id,
-        s.message_id AS message_id,
-        s.text AS text,
-        s.created_at AS created_at,
-        bm25(memory_segment_fts) AS rank
-      FROM memory_segment_fts f
-      JOIN memory_segments s ON s.id = f.segment_id
-      WHERE memory_segment_fts MATCH ?${scopeClause}
-      ORDER BY rank
-      LIMIT ?
-    `).all(...params) as Array<{
-      segment_id: string;
-      message_id: string;
-      text: string;
-      created_at: number;
-      rank: number;
-    }>;
-  } catch (err) {
-    log.warn({ err, query: truncate(trimmed, 80) }, 'Memory lexical search query parse failed');
-    return [];
+
+  // Adaptive overfetch: when exclusions are present, double the SQL LIMIT until we
+  // collect `limit` visible rows or the DB has no more matching results to offer.
+  // This handles dense exclusion sets without wasteful fixed-ratio over-fetching.
+  const MAX_FETCH_MULTIPLIER = 8;
+  let queryLimit = excluded.size > 0 ? Math.max(limit * 2, limit + 24) : limit;
+  let visibleRows: FtsRow[] = [];
+
+  while (true) {
+    let rows: FtsRow[] = [];
+    try {
+      rows = timedRawQuery('lexicalSearch', () =>
+        rawAll<FtsRow>(`
+          SELECT
+            f.segment_id AS segment_id,
+            s.message_id AS message_id,
+            s.text AS text,
+            s.created_at AS created_at,
+            bm25(memory_segment_fts) AS rank
+          FROM memory_segment_fts f
+          JOIN memory_segments s ON s.id = f.segment_id
+          WHERE memory_segment_fts MATCH ?${scopeClause}
+          ORDER BY rank
+          LIMIT ?
+        `, matchQuery, ...(scopeIds ?? []), queryLimit),
+      );
+    } catch (err) {
+      log.warn({ err, query: truncate(trimmed, 80) }, 'Memory lexical search query parse failed');
+      return [];
+    }
+
+    visibleRows = excluded.size > 0
+      ? rows.filter((row) => !excluded.has(row.message_id))
+      : rows;
+
+    // Stop when we have enough rows, the DB returned fewer than requested
+    // (no more results exist), or we've reached the safety cap.
+    if (visibleRows.length >= limit || rows.length < queryLimit || queryLimit >= limit * MAX_FETCH_MULTIPLIER) {
+      break;
+    }
+    queryLimit = Math.min(queryLimit * 2, limit * MAX_FETCH_MULTIPLIER);
   }
 
-  const visibleRows = excluded.size > 0
-    ? rows.filter((row) => !excluded.has(row.message_id)).slice(0, limit)
-    : rows;
+  visibleRows = visibleRows.slice(0, limit);
 
   const finiteRanks = visibleRows
     .map((row) => row.rank)
@@ -124,17 +153,19 @@ export function recencySearch(conversationId: string, limit: number, excludedMes
  * Supplements FTS-based lexical search with LIKE-based matching on items.
  */
 export function directItemSearch(query: string, limit: number, scopeIds?: string[]): Candidate[] {
-  const db = getDb();
   const tokens = [...new Set(query
     .toLowerCase()
     .split(/[^a-z0-9_.-]+/g)
     .filter((t) => t.length >= 2))];
   if (tokens.length === 0) return [];
 
-  const raw = (db as unknown as { $client: { query: (q: string) => { all: (...params: unknown[]) => unknown[] } } }).$client;
   const likeClauses = tokens.map(
-    (t) => `(LOWER(subject) LIKE '%${escapeSqlLike(t)}%' OR LOWER(statement) LIKE '%${escapeSqlLike(t)}%')`,
+    () => `(LOWER(subject) LIKE ? OR LOWER(statement) LIKE ?)`,
   );
+  const likeParams = tokens.flatMap((t) => {
+    const pattern = `%${escapeLikeWildcards(t)}%`;
+    return [pattern, pattern];
+  });
   const scopeClause = scopeIds
     ? ` AND scope_id IN (${scopeIds.map(() => '?').join(',')})`
     : '';
@@ -145,9 +176,8 @@ export function directItemSearch(query: string, limit: number, scopeIds?: string
     ORDER BY last_seen_at DESC
     LIMIT ?
   `;
-  const params: unknown[] = [...(scopeIds ?? []), limit];
 
-  let rows: Array<{
+  interface ItemRow {
     id: string;
     kind: string;
     subject: string;
@@ -156,9 +186,13 @@ export function directItemSearch(query: string, limit: number, scopeIds?: string
     importance: number | null;
     first_seen_at: number;
     last_seen_at: number;
-  }> = [];
+  }
+
+  let rows: ItemRow[] = [];
   try {
-    rows = raw.query(sqlQuery).all(...params) as typeof rows;
+    rows = timedRawQuery('directItemSearch', () =>
+      rawAll<ItemRow>(sqlQuery, ...likeParams, ...(scopeIds ?? []), limit),
+    );
   } catch {
     return [];
   }
@@ -212,11 +246,6 @@ export function buildFtsMatchQuery(text: string): string | null {
     .join(' OR ');
 }
 
-export function escapeSqlLike(s: string): string {
-  return s.replace(/'/g, "''").replace(/%/g, '').replace(/_/g, '');
-}
-
-/** Escape only LIKE wildcards (% and _) for use with parameterized queries where the driver handles quoting. */
 export function escapeLikeWildcards(s: string): string {
   return s.replace(/%/g, '').replace(/_/g, '');
 }

package/src/memory/search/ranking.ts

@@ -1,9 +1,8 @@
 import { inArray, sql } from 'drizzle-orm';
-import Anthropic from '@anthropic-ai/sdk';
 import type { AssistantConfig, MemoryRerankingConfig } from '../../config/types.js';
-import { getConfig } from '../../config/loader.js';
 import { estimateTextTokens } from '../../context/token-estimator.js';
 import { getLogger } from '../../util/logger.js';
+import { getConfiguredProvider, extractText, userMessage } from '../../providers/provider-send-message.js';
 import { getDb } from '../db.js';
 import { memoryItems } from '../schema.js';
 import type { Candidate, CandidateSource, ItemMetadata } from './types.js';
@@ -53,6 +52,7 @@ export function mergeCandidates(
   entity: Candidate[] = [],
   freshnessConfig?: { enabled: boolean; maxAgeDays: Record<string, number>; staleDecay: number; reinforcementShieldDays: number },
   relationScoreMultiplier?: number,
+  candidateDepthMap?: Map<string, number>,
 ): Candidate[] {
   // Build effective weight map that reflects the actual scoring weight for
   // each source.  For entity_relation the static SOURCE_WEIGHTS entry is 1.0
@@ -126,7 +126,11 @@ export function mergeCandidates(
     const lastUsedAt = meta?.lastUsedAt ?? null;
     const freshnessWeight = computeFreshnessWeight(row, accessCount, lastUsedAt, freshnessConfig);
 
-    const sourceWeight = effectiveWeights[row.source] ?? 1.0;
+    let sourceWeight = effectiveWeights[row.source] ?? 1.0;
+    if (row.source === 'entity_relation' && candidateDepthMap && relationScoreMultiplier != null) {
+      const depth = candidateDepthMap.get(row.key) ?? 1;
+      sourceWeight = Math.pow(relationScoreMultiplier, depth);
+    }
     row.finalScore = rrfScore * (0.5 + 0.5 * effectiveImportance) * trustWeight * freshnessWeight * sourceWeight;
   }
 
@@ -291,10 +295,9 @@ export async function rerankWithLLM(
   candidates: Candidate[],
   rerankingConfig: MemoryRerankingConfig,
 ): Promise<Candidate[]> {
-  const config = getConfig();
-  const apiKey = config.apiKeys.anthropic ?? process.env.ANTHROPIC_API_KEY;
-  if (!apiKey) {
-    log.debug('No Anthropic API key available for LLM re-ranking, skipping');
+  const provider = getConfiguredProvider();
+  if (!provider) {
+    log.debug('Configured provider unavailable for LLM re-ranking, skipping');
     return candidates;
   }
 
@@ -304,26 +307,27 @@ export async function rerankWithLLM(
     text: truncate(c.text, 200),
   }));
 
-  const client = new Anthropic({ apiKey });
-  const response = await client.messages.create({
-    model: rerankingConfig.model,
-    max_tokens: 1024,
-    system: 'You are a relevance scoring assistant. Given a query and a list of memory candidates, rate each candidate\'s relevance to the query on a scale of 0-10. Return ONLY a JSON array of objects with "index" (the candidate index) and "score" (0-10 integer). No explanation.',
-    messages: [{
-      role: 'user',
-      content: `Query: ${truncate(query, 200)}\n\nCandidates:\n${candidateList.map((c) => `[${c.index}] ${c.text}`).join('\n')}`,
-    }],
-  });
+  const response = await provider.sendMessage(
+    [userMessage(`Query: ${truncate(query, 200)}\n\nCandidates:\n${candidateList.map((c) => `[${c.index}] ${c.text}`).join('\n')}`)],
+    undefined,
+    'You are a relevance scoring assistant. Given a query and a list of memory candidates, rate each candidate\'s relevance to the query on a scale of 0-10. Return ONLY a JSON array of objects with "index" (the candidate index) and "score" (0-10 integer). No explanation.',
+    {
+      config: {
+        model: rerankingConfig.model,
+        max_tokens: 1024,
+      },
+    },
+  );
 
   // Extract text from the response
-  const textBlock = response.content.find((block) => block.type === 'text');
-  if (!textBlock || textBlock.type !== 'text') {
+  const responseText = extractText(response);
+  if (!responseText) {
     log.warn('LLM re-ranking returned no text block, skipping');
     return candidates;
   }
 
   // Parse the JSON array from the response
-  const jsonMatch = textBlock.text.match(/\[[\s\S]*\]/);
+  const jsonMatch = responseText.match(/\[[\s\S]*\]/);
   if (!jsonMatch) {
     log.warn('LLM re-ranking response did not contain JSON array, skipping');
     return candidates;
@@ -354,10 +358,10 @@ export async function rerankWithLLM(
 
   reranked.sort((a, b) => {
     // Scored items come before unscored items
-    if (a.llmScore !== null && b.llmScore === null) return -1;
-    if (a.llmScore === null && b.llmScore !== null) return 1;
+    if (a.llmScore != null && b.llmScore == null) return -1;
+    if (a.llmScore == null && b.llmScore != null) return 1;
     // Both scored: sort by score descending
-    if (a.llmScore !== null && b.llmScore !== null) {
+    if (a.llmScore != null && b.llmScore != null) {
       const scoreDelta = b.llmScore - a.llmScore;
       if (scoreDelta !== 0) return scoreDelta;
     }

package/src/memory/search/semantic.ts

@@ -1,6 +1,7 @@
-import { eq } from 'drizzle-orm';
+import { inArray } from 'drizzle-orm';
 import { getDb } from '../db.js';
 import { getQdrantClient } from '../qdrant-client.js';
+import type { QdrantSearchResult } from '../qdrant-client.js';
 import {
   memoryItems,
   memoryItemSources,
@@ -9,6 +10,84 @@ import {
 } from '../schema.js';
 import type { Candidate } from './types.js';
 import { computeRecencyScore } from './ranking.js';
+import { getLogger } from '../../util/logger.js';
+
+const log = getLogger('qdrant-circuit-breaker');
+
+// ── Qdrant circuit breaker ───────────────────────────────────────────
+// After FAILURE_THRESHOLD consecutive Qdrant failures, stop sending
+// requests (open state). After COOLDOWN_MS, allow a single probe
+// request (half-open). If the probe succeeds, close the circuit; if it
+// fails, re-open and restart the cooldown.
+
+const FAILURE_THRESHOLD = 5;
+const COOLDOWN_MS = 60_000;
+
+type BreakerState = 'closed' | 'open' | 'half-open';
+
+let breakerState: BreakerState = 'closed';
+let consecutiveFailures = 0;
+let openedAt = 0;
+// Ensures only one request passes through during half-open state
+let halfOpenProbeInFlight = false;
+
+function qdrantBreakerAllows(): boolean {
+  if (breakerState === 'closed') return true;
+  if (breakerState === 'open') {
+    if (Date.now() - openedAt >= COOLDOWN_MS) {
+      breakerState = 'half-open';
+      halfOpenProbeInFlight = true;
+      log.info('Qdrant circuit breaker entering half-open state — allowing probe request');
+      return true;
+    }
+    return false;
+  }
+  // half-open: only allow through if no probe is already in flight
+  if (halfOpenProbeInFlight) return false;
+  halfOpenProbeInFlight = true;
+  return true;
+}
+
+function qdrantBreakerRecordSuccess(): void {
+  if (breakerState !== 'closed') {
+    log.info({ previousFailures: consecutiveFailures }, 'Qdrant circuit breaker closed — search succeeded');
+  }
+  consecutiveFailures = 0;
+  breakerState = 'closed';
+  openedAt = 0;
+  halfOpenProbeInFlight = false;
+}
+
+function qdrantBreakerRecordFailure(): void {
+  consecutiveFailures++;
+  halfOpenProbeInFlight = false;
+  if (consecutiveFailures >= FAILURE_THRESHOLD) {
+    breakerState = 'open';
+    openedAt = Date.now();
+    log.warn(
+      { consecutiveFailures, cooldownMs: COOLDOWN_MS },
+      'Qdrant circuit breaker opened — semantic search disabled until probe succeeds',
+    );
+  } else if (breakerState === 'half-open') {
+    // Probe failed — re-open
+    breakerState = 'open';
+    openedAt = Date.now();
+    log.warn('Qdrant circuit breaker re-opened — half-open probe failed');
+  }
+}
+
+/** @internal Test-only: reset circuit breaker state */
+export function _resetQdrantBreaker(): void {
+  breakerState = 'closed';
+  consecutiveFailures = 0;
+  openedAt = 0;
+  halfOpenProbeInFlight = false;
+}
+
+/** @internal Test-only: get breaker state */
+export function _getQdrantBreakerState(): { state: BreakerState; consecutiveFailures: number } {
+  return { state: breakerState, consecutiveFailures };
+}
 
 export async function semanticSearch(
   queryVector: number[],
@@ -20,18 +99,79 @@ export async function semanticSearch(
 ): Promise<Candidate[]> {
   if (limit <= 0) return [];
 
+  // Circuit breaker: throw so the caller's .catch() marks the result as degraded
+  if (!qdrantBreakerAllows()) {
+    log.debug('Qdrant circuit breaker open — skipping semantic search');
+    throw new Error('Qdrant circuit breaker open');
+  }
+
   const qdrant = getQdrantClient();
 
   // Overfetch to account for items filtered out post-query (invalidated, excluded, etc.)
-  const fetchLimit = limit * 2;
-  const results = await qdrant.searchWithFilter(
-    queryVector,
-    fetchLimit,
-    ['item', 'summary', 'segment'],
-    excludedMessageIds,
-  );
+  // Use 3x when exclusions are active to ensure enough results survive filtering
+  const overfetchMultiplier = excludedMessageIds.length > 0 ? 3 : 2;
+  const fetchLimit = limit * overfetchMultiplier;
+  let results: QdrantSearchResult[];
+  try {
+    results = await qdrant.searchWithFilter(
+      queryVector,
+      fetchLimit,
+      ['item', 'summary', 'segment'],
+      excludedMessageIds,
+    );
+    qdrantBreakerRecordSuccess();
+  } catch (err) {
+    qdrantBreakerRecordFailure();
+    throw err;
+  }
 
   const db = getDb();
+
+  // Batch-fetch all backing records upfront to avoid N+1 queries per result
+  const itemTargetIds: string[] = [];
+  const summaryTargetIds: string[] = [];
+  const segmentTargetIds: string[] = [];
+  for (const r of results) {
+    if (r.payload.target_type === 'item') itemTargetIds.push(r.payload.target_id);
+    else if (r.payload.target_type === 'summary') summaryTargetIds.push(r.payload.target_id);
+    else segmentTargetIds.push(r.payload.target_id);
+  }
+
+  const itemsMap = new Map<string, typeof memoryItems.$inferSelect>();
+  if (itemTargetIds.length > 0) {
+    const allItems = db.select().from(memoryItems).where(inArray(memoryItems.id, itemTargetIds)).all();
+    for (const item of allItems) itemsMap.set(item.id, item);
+  }
+
+  const sourcesMap = new Map<string, string[]>();
+  if (itemTargetIds.length > 0) {
+    const allSources = db.select({
+      memoryItemId: memoryItemSources.memoryItemId,
+      messageId: memoryItemSources.messageId,
+    }).from(memoryItemSources)
+      .where(inArray(memoryItemSources.memoryItemId, itemTargetIds))
+      .all();
+    for (const s of allSources) {
+      const existing = sourcesMap.get(s.memoryItemId);
+      if (existing) existing.push(s.messageId);
+      else sourcesMap.set(s.memoryItemId, [s.messageId]);
+    }
+  }
+
+  const summariesMap = new Map<string, typeof memorySummaries.$inferSelect>();
+  if (scopeIds && summaryTargetIds.length > 0) {
+    const allSummaries = db.select().from(memorySummaries).where(inArray(memorySummaries.id, summaryTargetIds)).all();
+    for (const s of allSummaries) summariesMap.set(s.id, s);
+  }
+
+  const segmentsMap = new Map<string, typeof memorySegments.$inferSelect>();
+  if (scopeIds && segmentTargetIds.length > 0) {
+    const allSegments = db.select().from(memorySegments).where(inArray(memorySegments.id, segmentTargetIds)).all();
+    for (const seg of allSegments) segmentsMap.set(seg.id, seg);
+  }
+
+  const excludedSet = excludedMessageIds.length > 0 ? new Set(excludedMessageIds) : null;
+
   const candidates: Candidate[] = [];
   for (const result of results) {
     const { payload, score } = result;
@@ -39,16 +179,14 @@ export async function semanticSearch(
     const createdAt = payload.created_at ?? Date.now();
 
     if (payload.target_type === 'item') {
-      // Validate the backing memory item is still active and has non-excluded evidence
-      const item = db.select().from(memoryItems).where(eq(memoryItems.id, payload.target_id)).get();
-      if (!item || item.status !== 'active' || item.invalidAt !== null) continue;
+      const item = itemsMap.get(payload.target_id);
+      if (!item || item.status !== 'active' || item.invalidAt != null) continue;
       if (scopeIds && !scopeIds.includes(item.scopeId)) continue;
-      const sources = db.select().from(memoryItemSources)
-        .where(eq(memoryItemSources.memoryItemId, payload.target_id)).all();
-      if (sources.length === 0) continue;
-      if (excludedMessageIds.length > 0) {
-        const nonExcluded = sources.filter((s) => !excludedMessageIds.includes(s.messageId));
-        if (nonExcluded.length === 0) continue;
+      const sources = sourcesMap.get(payload.target_id);
+      if (!sources || sources.length === 0) continue;
+      if (excludedSet) {
+        const hasNonExcluded = sources.some((msgId) => !excludedSet.has(msgId));
+        if (!hasNonExcluded) continue;
       }
       candidates.push({
         key: `item:${payload.target_id}`,
@@ -67,7 +205,7 @@ export async function semanticSearch(
       });
     } else if (payload.target_type === 'summary') {
       if (scopeIds) {
-        const summary = db.select().from(memorySummaries).where(eq(memorySummaries.id, payload.target_id)).get();
+        const summary = summariesMap.get(payload.target_id);
         if (!summary || !scopeIds.includes(summary.scopeId)) continue;
       }
       candidates.push({
@@ -87,7 +225,7 @@ export async function semanticSearch(
       });
     } else {
       if (scopeIds) {
-        const segment = db.select().from(memorySegments).where(eq(memorySegments.id, payload.target_id)).get();
+        const segment = segmentsMap.get(payload.target_id);
         if (!segment || !scopeIds.includes(segment.scopeId)) continue;
       }
       candidates.push({

package/src/memory/search/types.ts

@@ -105,6 +105,7 @@ export interface EntitySearchResult {
   relationTraversedEdgeCount: number;
   relationNeighborEntityCount: number;
   relationExpandedItemCount: number;
+  candidateDepths?: Map<string, number>; // candidate key → BFS hop depth (1-based)
 }
 
 export interface MatchedEntityRow {
@@ -137,3 +138,26 @@ export interface MemorySearchResult {
     recency: number;
   };
 }
+
+import type { EntityRelationType, EntityType } from '../entity-extractor.js';
+
+export interface TraversalOptions {
+  maxEdges: number;
+  maxNeighborEntities: number;
+  maxDepth?: number; // default 3
+  relationTypes?: EntityRelationType[];
+  entityTypes?: EntityType[];
+  /** When true, only follow source→target edges (frontier must be on source side). */
+  directed?: boolean;
+}
+
+export interface TraversalResult {
+  neighborEntityIds: string[];
+  traversedEdgeCount: number;
+  neighborDepths: Map<string, number>; // entityId → depth (1-based)
+}
+
+export interface TraversalStep {
+  relationTypes?: EntityRelationType[];
+  entityTypes?: EntityType[];
+}

package/src/memory/shared-app-links-store.ts

@@ -6,7 +6,7 @@
 
 import { eq, lte, or, and, isNull } from 'drizzle-orm';
 import { randomUUID, randomBytes } from 'node:crypto';
-import { getDb } from './db.js';
+import { getDb, rawRun } from './db.js';
 import { sharedAppLinks } from './schema.js';
 import type { AppManifest } from '../bundler/manifest.js';
 
@@ -130,9 +130,8 @@ export function deleteSharedAppLinkByToken(shareToken: string): boolean {
 }
 
 export function incrementDownloadCount(shareToken: string): void {
-  const db = getDb();
-  const raw = (db as unknown as { $client: import('bun:sqlite').Database }).$client;
-  raw.prepare(
+  rawRun(
     `UPDATE shared_app_links SET download_count = download_count + 1 WHERE share_token = ?`,
-  ).run(shareToken);
+    shareToken,
+  );
 }

package/src/memory/validation.ts

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+
+/**
+ * Unit interval [0, 1] — used for confidence and importance fields on memory items.
+ * Coerces out-of-range numbers to the nearest bound rather than rejecting,
+ * since LLM-generated values occasionally exceed the range.
+ */
+export const unitInterval = z.number().transform((v) => Math.min(1, Math.max(0, v)));
+
+/** Zod schema for validating confidence/importance values on memory items. */
+export const memoryItemScores = z.object({
+  confidence: unitInterval,
+  importance: unitInterval,
+});
+
+/** Clamp a numeric value to [0, 1]. */
+export function clampUnitInterval(value: number): number {
+  return Math.min(1, Math.max(0, value));
+}

package/src/messaging/draft-store.ts

@@ -5,8 +5,9 @@
  * Works across all platforms — Slack, Gmail, Discord, etc.
  */
 
-import { existsSync, mkdirSync, readFileSync, writeFileSync, unlinkSync, readdirSync } from 'node:fs';
+import { readFileSync, writeFileSync, unlinkSync, readdirSync } from 'node:fs';
 import { join } from 'node:path';
+import { ensureDir, pathExists } from '../util/fs.js';
 import { randomUUID } from 'node:crypto';
 import { getRootDir } from '../util/platform.js';
 
@@ -24,9 +25,7 @@ export interface Draft {
 
 function getDraftsDir(platform: string): string {
   const dir = join(getRootDir(), 'workspace', 'data', 'drafts', platform);
-  if (!existsSync(dir)) {
-    mkdirSync(dir, { recursive: true });
-  }
+  ensureDir(dir);
   return dir;
 }
 
@@ -61,7 +60,7 @@ export function createDraft(opts: {
 
 export function getDraft(platform: string, id: string): Draft | null {
   const path = getDraftPath(platform, id);
-  if (!existsSync(path)) return null;
+  if (!pathExists(path)) return null;
   return JSON.parse(readFileSync(path, 'utf-8')) as Draft;
 }
 
@@ -82,7 +81,7 @@ export function listDrafts(platform: string): Draft[] {
 
 export function deleteDraft(platform: string, id: string): boolean {
   const path = getDraftPath(platform, id);
-  if (!existsSync(path)) return false;
+  if (!pathExists(path)) return false;
   unlinkSync(path);
   return true;
 }

package/src/messaging/provider-types.ts

@@ -77,4 +77,6 @@ export interface SendOptions {
   subject?: string;
   /** For email: in-reply-to message ID */
   inReplyTo?: string;
+  /** Optional assistant scope for multi-assistant channels. */
+  assistantId?: string;
 }