@vellumai/assistant 0.7.0 → 0.7.2

package/src/config/schemas/memory-retrieval.ts

@@ -1,6 +1,6 @@
 import { z } from "zod";
 
-export const MemoryDynamicBudgetConfigSchema = z
+const MemoryDynamicBudgetConfigSchema = z
   .object({
     enabled: z
       .boolean({
@@ -271,7 +271,7 @@ const MemoryPerTurnInjectionSchema = z
   })
   .describe("Memory injection limits for mid-conversation turns");
 
-export const MemoryInjectionConfigSchema = z
+const MemoryInjectionConfigSchema = z
   .object({
     contextLoad: MemoryContextLoadInjectionSchema.default(
       MemoryContextLoadInjectionSchema.parse({}),

package/src/config/schemas/memory-v2.ts

@@ -87,6 +87,15 @@ export const MemoryV2ConfigSchema = z
       .describe(
         "Number of top-activation concept pages considered for injection per turn",
       ),
+    ann_candidate_limit: z
+      .number({ error: "memory.v2.ann_candidate_limit must be a number" })
+      .int("memory.v2.ann_candidate_limit must be an integer")
+      .positive("memory.v2.ann_candidate_limit must be a positive integer")
+      .nullable()
+      .default(null)
+      .describe(
+        "Per-channel cap on the unrestricted ANN candidate query (dense and sparse each return up to this many hits before they are unioned and fed into the activation pipeline). `null` = unlimited (every page in the v2 collection is eligible). Increase or null this out to surface more candidates at the cost of higher per-turn embedding/scoring work.",
+      ),
     top_k_skills: z
       .number({ error: "memory.v2.top_k_skills must be a number" })
       .int()
@@ -107,17 +116,52 @@ export const MemoryV2ConfigSchema = z
       .number({ error: "memory.v2.dense_weight must be a number" })
       .min(0, "memory.v2.dense_weight must be >= 0")
       .max(1, "memory.v2.dense_weight must be <= 1")
-      .default(0.7)
+      .default(0.85)
       .describe(
-        "Weight on dense (cosine) similarity in the hybrid retrieval score",
+        "Weight on dense (cosine) similarity in the hybrid retrieval score — dense embeddings dominate the score.",
       ),
     sparse_weight: z
       .number({ error: "memory.v2.sparse_weight must be a number" })
       .min(0, "memory.v2.sparse_weight must be >= 0")
       .max(1, "memory.v2.sparse_weight must be <= 1")
-      .default(0.3)
+      .default(0.15)
+      .describe(
+        "Weight on sparse (BM25-style) similarity in the hybrid retrieval score — sparse acts as a discriminator for keyword-rich queries.",
+      ),
+    // Adaptive sparse-weighting knobs. Both fields are intentionally
+    // optional with no default — the schema serialiser drops absent
+    // optionals so these stay invisible to operators who never tune them.
+    // The defaults live in `effectiveWeights` (sim.ts).
+    min_sparse_spread: z
+      .number({ error: "memory.v2.min_sparse_spread must be a number" })
+      .min(0, "memory.v2.min_sparse_spread must be >= 0")
+      .max(1, "memory.v2.min_sparse_spread must be <= 1")
+      .optional()
+      .describe(
+        "Adaptive sparse weighting: when the spread (max - min) of normalized sparse scores across the candidate hit set falls below this, sparse contribution collapses to 0. Linear interpolation between this and `full_sparse_spread`. Optional escape hatch — leave unset to use the built-in default.",
+      ),
+    full_sparse_spread: z
+      .number({ error: "memory.v2.full_sparse_spread must be a number" })
+      .min(0, "memory.v2.full_sparse_spread must be >= 0")
+      .max(1, "memory.v2.full_sparse_spread must be <= 1")
+      .optional()
       .describe(
-        "Weight on sparse (BM25-style) similarity in the hybrid retrieval score",
+        "Adaptive sparse weighting: at or above this spread, sparse weight stays at the configured `sparse_weight`. Optional escape hatch — leave unset to use the built-in default.",
+      ),
+    bm25_k1: z
+      .number({ error: "memory.v2.bm25_k1 must be a number" })
+      .min(0, "memory.v2.bm25_k1 must be >= 0")
+      .default(1.2)
+      .describe(
+        "BM25 term-frequency saturation parameter. Standard Lucene default — increase to make repeated mentions of a term matter more, decrease to flatten the curve.",
+      ),
+    bm25_b: z
+      .number({ error: "memory.v2.bm25_b must be a number" })
+      .min(0, "memory.v2.bm25_b must be >= 0")
+      .max(1, "memory.v2.bm25_b must be <= 1")
+      .default(0.4)
+      .describe(
+        "BM25 document-length normalization. 0 disables length normalization, 1 fully normalizes. Lucene's default is 0.75 (tuned for narrative/web corpora); we run lower because concept-page collections include structured list pages with high information density per word — full Lucene normalization over-penalizes them.",
       ),
     consolidation_interval_hours: z
       .number({
@@ -139,6 +183,15 @@ export const MemoryV2ConfigSchema = z
       .describe(
         "Soft upper bound on concept-page body length — pages exceeding this are flagged for split during consolidation",
       ),
+    consolidation_prompt_path: z
+      .string({
+        error: "memory.v2.consolidation_prompt_path must be a string",
+      })
+      .nullable()
+      .default(null)
+      .describe(
+        "Optional path to a file whose contents replace the bundled consolidation prompt. Absolute paths are used as-is, a leading `~/` is expanded to the home directory, otherwise the path is resolved under the workspace root. The loaded contents may include `{{CUTOFF}}`, which is substituted with the run's ISO-8601 cutoff timestamp. If the file is missing, unreadable, or empty, the bundled prompt is used and a warning is logged.",
+      ),
   })
   .describe(
     "Memory v2 — concept-page activation model with hourly LLM-driven consolidation",

package/src/config/schemas/platform.ts

@@ -10,6 +10,12 @@ export const PlatformConfigSchema = z
       )
       .default("")
       .describe("Base URL of the Vellum platform API"),
+    subdomain: z
+      .string({ error: "platform.subdomain must be a string" })
+      .default("")
+      .describe(
+        "Registered subdomain on vellum.me (e.g. 'apollobot' → apollobot.vellum.me). Set automatically by 'assistant domain register'.",
+      ),
   })
   .describe("Vellum platform connection settings");
 

package/src/config/schemas/security.ts

@@ -1,46 +1,11 @@
 import { z } from "zod";
 
-const VALID_SECRET_ACTIONS = ["redact", "warn", "block", "prompt"] as const;
-
-const CustomSecretPatternSchema = z
-  .object({
-    label: z
-      .string({
-        error: "secretDetection.customPatterns[].label must be a string",
-      })
-      .describe("Human-readable label for this secret pattern"),
-    pattern: z
-      .string({
-        error: "secretDetection.customPatterns[].pattern must be a string",
-      })
-      .describe("Regular expression pattern to match secrets"),
-  })
-  .describe("Custom pattern for detecting secrets in messages");
-
 export const SecretDetectionConfigSchema = z
   .object({
     enabled: z
       .boolean({ error: "secretDetection.enabled must be a boolean" })
       .default(true)
       .describe("Whether automatic secret detection is enabled"),
-    action: z
-      .enum(VALID_SECRET_ACTIONS, {
-        error: `secretDetection.action must be one of: ${VALID_SECRET_ACTIONS.join(
-          ", ",
-        )}`,
-      })
-      .default("redact")
-      .describe(
-        "Action to take when a secret is detected: redact (replace with placeholder), warn (log a warning), block (reject the message), or prompt (ask the user)",
-      ),
-    entropyThreshold: z
-      .number({ error: "secretDetection.entropyThreshold must be a number" })
-      .finite("secretDetection.entropyThreshold must be finite")
-      .positive("secretDetection.entropyThreshold must be a positive number")
-      .default(4.0)
-      .describe(
-        "Shannon entropy threshold for detecting high-entropy strings as potential secrets",
-      ),
     blockIngress: z
       .boolean({ error: "secretDetection.blockIngress must be a boolean" })
       .default(true)
@@ -53,15 +18,9 @@ export const SecretDetectionConfigSchema = z
       .describe(
         "Whether to allow sending a detected secret once (with user confirmation) before redacting future occurrences",
       ),
-    customPatterns: z
-      .array(CustomSecretPatternSchema)
-      .optional()
-      .describe(
-        "Additional regex patterns for detecting domain-specific secrets",
-      ),
   })
   .describe(
-    "Automatic secret detection and redaction to prevent leaking sensitive data",
+    "Prefix-based secret detection at user-message ingress, plus one-time-send override for the secure credential prompt",
   );
 
 export type SecretDetectionConfig = z.infer<typeof SecretDetectionConfigSchema>;

package/src/config/schemas/services.ts

@@ -3,8 +3,8 @@ import { z } from "zod";
 import { SttServiceSchema } from "./stt.js";
 import { TtsServiceSchema } from "./tts.js";
 
-export const ServiceModeSchema = z.enum(["managed", "your-own"]);
-export type ServiceMode = z.infer<typeof ServiceModeSchema>;
+const ServiceModeSchema = z.enum(["managed", "your-own"]);
+type ServiceMode = z.infer<typeof ServiceModeSchema>;
 
 export const VALID_INFERENCE_PROVIDERS = [
   "anthropic",
@@ -15,9 +15,9 @@ export const VALID_INFERENCE_PROVIDERS = [
   "openrouter",
 ] as const;
 
-export const VALID_IMAGE_GEN_PROVIDERS = ["gemini", "openai"] as const;
+const VALID_IMAGE_GEN_PROVIDERS = ["gemini", "openai"] as const;
 
-export const VALID_WEB_SEARCH_PROVIDERS = [
+const VALID_WEB_SEARCH_PROVIDERS = [
   "perplexity",
   "brave",
   "inference-provider-native",
@@ -26,7 +26,6 @@ export const VALID_WEB_SEARCH_PROVIDERS = [
 const BaseServiceSchema = z.object({
   mode: ServiceModeSchema.default("your-own"),
 });
-export type BaseService = z.infer<typeof BaseServiceSchema>;
 
 /**
  * Inference service entry. Carries only the routing `mode`
@@ -36,53 +35,42 @@ export type BaseService = z.infer<typeof BaseServiceSchema>;
  * legacy configs that still carry them have those keys stripped by
  * workspace migration `039-drop-legacy-llm-keys`.
  */
-export const InferenceServiceSchema = BaseServiceSchema;
-export type InferenceService = z.infer<typeof InferenceServiceSchema>;
+const InferenceServiceSchema = BaseServiceSchema;
 
-export const ImageGenerationServiceSchema = BaseServiceSchema.extend({
+const ImageGenerationServiceSchema = BaseServiceSchema.extend({
   provider: z.enum(VALID_IMAGE_GEN_PROVIDERS).default("gemini"),
   model: z.string().default("gemini-3.1-flash-image-preview"),
 });
-export type ImageGenerationService = z.infer<
-  typeof ImageGenerationServiceSchema
->;
 
-export const WebSearchServiceSchema = BaseServiceSchema.extend({
+const WebSearchServiceSchema = BaseServiceSchema.extend({
   provider: z
     .enum(VALID_WEB_SEARCH_PROVIDERS)
     .default("inference-provider-native"),
 });
-export type WebSearchService = z.infer<typeof WebSearchServiceSchema>;
 
 const GoogleOAuthServiceSchema = BaseServiceSchema.extend({
   mode: ServiceModeSchema.default("your-own"),
 });
-export type GoogleOAuthService = z.infer<typeof GoogleOAuthServiceSchema>;
 
 const OutlookOAuthServiceSchema = BaseServiceSchema.extend({
   mode: ServiceModeSchema.default("your-own"),
 });
-export type OutlookOAuthService = z.infer<typeof OutlookOAuthServiceSchema>;
 
 const LinearOAuthServiceSchema = BaseServiceSchema.extend({
   mode: ServiceModeSchema.default("your-own"),
 });
-export type LinearOAuthService = z.infer<typeof LinearOAuthServiceSchema>;
 
 const GitHubOAuthServiceSchema = BaseServiceSchema.extend({
   mode: ServiceModeSchema.default("your-own"),
 });
-export type GitHubOAuthService = z.infer<typeof GitHubOAuthServiceSchema>;
 
 const NotionOAuthServiceSchema = BaseServiceSchema.extend({
   mode: ServiceModeSchema.default("your-own"),
 });
-export type NotionOAuthService = z.infer<typeof NotionOAuthServiceSchema>;
 
 const TwitterOAuthServiceSchema = BaseServiceSchema.extend({
   mode: ServiceModeSchema.default("your-own"),
 });
-export type TwitterOAuthService = z.infer<typeof TwitterOAuthServiceSchema>;
 
 /**
  * `services.meet.host.*` — daemon-side knobs for the externalized meet-join
@@ -106,7 +94,6 @@ const MeetHostConfigSchema = z
       ),
   })
   .describe("Daemon-side configuration for the external meet-join skill host");
-export type MeetHostConfig = z.infer<typeof MeetHostConfigSchema>;
 
 /**
  * Daemon-side `services.meet` block. Intentionally distinct from the
@@ -120,7 +107,6 @@ const MeetDaemonServiceSchema = z
     host: MeetHostConfigSchema.default(MeetHostConfigSchema.parse({})),
   })
   .describe("meet-join skill daemon-side configuration");
-export type MeetDaemonService = z.infer<typeof MeetDaemonServiceSchema>;
 
 export const ServicesSchema = z.object({
   inference: InferenceServiceSchema.default(InferenceServiceSchema.parse({})),

package/src/config/schemas/skills.ts

@@ -24,7 +24,7 @@ export const SkillEntryConfigSchema = z
   })
   .describe("Configuration for an individual skill");
 
-export const SkillsLoadConfigSchema = z
+const SkillsLoadConfigSchema = z
   .object({
     extraDirs: z
       .array(
@@ -49,7 +49,7 @@ export const SkillsLoadConfigSchema = z
   })
   .describe("Controls how skills are discovered and loaded");
 
-export const SkillsInstallConfigSchema = z
+const SkillsInstallConfigSchema = z
   .object({
     nodeManager: z
       .enum(["npm", "pnpm", "yarn", "bun"], {
@@ -61,7 +61,7 @@ export const SkillsInstallConfigSchema = z
   })
   .describe("Skill dependency installation settings");
 
-export const RemoteProviderConfigSchema = z
+const RemoteProviderConfigSchema = z
   .object({
     enabled: z
       .boolean({
@@ -72,7 +72,7 @@ export const RemoteProviderConfigSchema = z
   })
   .describe("Configuration for a remote skill provider");
 
-export const RemoteProvidersConfigSchema = z
+const RemoteProvidersConfigSchema = z
   .object({
     skillssh: RemoteProviderConfigSchema.default(
       RemoteProviderConfigSchema.parse({}),
@@ -93,7 +93,7 @@ const VALID_MAX_RISK_LEVELS = [
   "critical",
 ] as const;
 
-export const RemotePolicyConfigSchema = z
+const RemotePolicyConfigSchema = z
   .object({
     blockSuspicious: z
       .boolean({
@@ -149,9 +149,3 @@ export const SkillsConfigSchema = z
   );
 
 export type SkillEntryConfig = z.infer<typeof SkillEntryConfigSchema>;
-export type SkillsLoadConfig = z.infer<typeof SkillsLoadConfigSchema>;
-export type SkillsInstallConfig = z.infer<typeof SkillsInstallConfigSchema>;
-export type RemoteProviderConfig = z.infer<typeof RemoteProviderConfigSchema>;
-export type RemoteProvidersConfig = z.infer<typeof RemoteProvidersConfigSchema>;
-export type RemotePolicyConfig = z.infer<typeof RemotePolicyConfigSchema>;
-export type SkillsConfig = z.infer<typeof SkillsConfigSchema>;

package/src/config/schemas/tts.ts

@@ -220,7 +220,7 @@ export const TtsXaiProviderConfigSchema = z
 
 export type TtsXaiProviderConfig = z.infer<typeof TtsXaiProviderConfigSchema>;
 
-export const TtsProvidersSchema = z.object({
+const TtsProvidersSchema = z.object({
   elevenlabs: TtsElevenLabsProviderConfigSchema.default(
     TtsElevenLabsProviderConfigSchema.parse({}),
   ),

package/src/config/seed-inference-profiles.ts

@@ -0,0 +1,117 @@
+import { loadRawConfig, saveRawConfig } from "./loader.js";
+import {
+  DEFAULT_CONTEXT_WINDOW_MAX_INPUT_TOKENS,
+  type ProfileEntry,
+} from "./schemas/llm.js";
+
+/**
+ * Declarative seed data for daemon-managed inference profiles.
+ *
+ * These profiles are overwritten on every startup so upstream model
+ * updates propagate automatically. User-created profiles (keyed by
+ * different names) are never touched.
+ */
+const MANAGED_PROFILE_SEED_DATA: Record<string, ProfileEntry> = {
+  balanced: {
+    source: "managed",
+    label: "Balanced",
+    description: "Good balance of quality, cost, and speed",
+    provider: "anthropic",
+    model: "claude-sonnet-4-6",
+    maxTokens: 16000,
+    effort: "high",
+    thinking: { enabled: true, streamThinking: true },
+    contextWindow: { maxInputTokens: DEFAULT_CONTEXT_WINDOW_MAX_INPUT_TOKENS },
+  },
+  "quality-optimized": {
+    source: "managed",
+    label: "Quality",
+    description: "Best results with the most capable model",
+    provider: "anthropic",
+    model: "claude-opus-4-7",
+    maxTokens: 32000,
+    effort: "max",
+    thinking: { enabled: true, streamThinking: true },
+    contextWindow: { maxInputTokens: DEFAULT_CONTEXT_WINDOW_MAX_INPUT_TOKENS },
+  },
+  "cost-optimized": {
+    source: "managed",
+    label: "Speed",
+    description: "Fastest responses at lower cost",
+    provider: "anthropic",
+    model: "claude-haiku-4-5-20251001",
+    maxTokens: 8192,
+    effort: "low",
+    thinking: { enabled: false, streamThinking: false },
+    contextWindow: { maxInputTokens: DEFAULT_CONTEXT_WINDOW_MAX_INPUT_TOKENS },
+  },
+};
+
+export const MANAGED_PROFILE_NAMES = new Set(
+  Object.keys(MANAGED_PROFILE_SEED_DATA),
+);
+
+/**
+ * Seed managed inference profiles into the workspace config.
+ *
+ * Called on every daemon startup after workspace migrations and before
+ * the first `loadConfig()`. Managed profiles are overwritten entirely
+ * (replace, not merge) so upstream model/effort changes propagate.
+ * User-created profiles are never touched; pre-existing profiles
+ * without a `source` field get `source: "user"` backfilled.
+ *
+ * No-op when `VELLUM_DEFAULT_WORKSPACE_CONFIG_PATH` is set (same guard
+ * as migration 052) because the platform-provided default-config overlay
+ * is the authoritative source for profile seeds.
+ */
+export function seedInferenceProfiles(): void {
+  if (process.env.VELLUM_DEFAULT_WORKSPACE_CONFIG_PATH) return;
+
+  const config = loadRawConfig();
+
+  if (config.llm == null || typeof config.llm !== "object") {
+    config.llm = {};
+  }
+  const llm = config.llm as Record<string, unknown>;
+
+  if (llm.profiles == null || typeof llm.profiles !== "object") {
+    llm.profiles = {};
+  }
+  const profiles = llm.profiles as Record<string, Record<string, unknown>>;
+
+  for (const [name, seed] of Object.entries(MANAGED_PROFILE_SEED_DATA)) {
+    profiles[name] = { ...seed };
+  }
+
+  // Reset to the default managed profile when the current value is missing.
+  if (
+    typeof llm.activeProfile !== "string" ||
+    !(llm.activeProfile in profiles)
+  ) {
+    llm.activeProfile = "balanced";
+  }
+
+  const profileOrder = Array.isArray(llm.profileOrder)
+    ? (llm.profileOrder as string[])
+    : [];
+  const orderSet = new Set(profileOrder);
+  for (const name of MANAGED_PROFILE_NAMES) {
+    if (!orderSet.has(name)) {
+      profileOrder.push(name);
+    }
+  }
+  llm.profileOrder = profileOrder;
+
+  for (const [name, profile] of Object.entries(profiles)) {
+    if (MANAGED_PROFILE_NAMES.has(name)) continue;
+    if (
+      profile != null &&
+      typeof profile === "object" &&
+      !("source" in profile)
+    ) {
+      profile.source = "user";
+    }
+  }
+
+  saveRawConfig(config);
+}

package/src/config/skills.ts

@@ -5,7 +5,6 @@ import {
   readFileSync,
   realpathSync,
   statSync,
-  writeFileSync,
 } from "node:fs";
 import {
   basename,
@@ -22,11 +21,6 @@ import {
   getPluginContributedSkillDefinition,
   getPluginContributedSkillSummaries,
 } from "../plugins/plugin-skill-contributions.js";
-import {
-  extractAllText,
-  getConfiguredProvider,
-  userMessage,
-} from "../providers/provider-send-message.js";
 import { parseFrontmatterFields } from "../skills/frontmatter.js";
 import type { InlineCommandExpansion } from "../skills/inline-command-expansions.js";
 import { parseInlineCommandExpansions } from "../skills/inline-command-expansions.js";
@@ -1232,87 +1226,3 @@ export function loadSkillBySelector(
 }
 
 // ─── Icon generation ─────────────────────────────────────────────────────────
-
-async function generateSkillIcon(
-  name: string,
-  description: string,
-): Promise<string> {
-  const provider = await getConfiguredProvider("skillCategoryInference");
-  if (!provider) {
-    throw new Error("Configured provider unavailable for icon generation");
-  }
-
-  const response = await provider.sendMessage(
-    [
-      userMessage(
-        `Create a 16x16 pixel art SVG icon representing this skill:\nName: ${name}\nDescription: ${description}`,
-      ),
-    ],
-    undefined,
-    'You are a pixel art icon designer. When asked, return ONLY a single <svg> element — no explanation, no markdown, no code fences. The SVG must be a 16x16 grid pixel art icon using <rect> elements. Use a limited palette (3-5 colors). Keep it under 2KB. The viewBox should be "0 0 16 16" with each pixel being a 1x1 rect.',
-    {
-      config: {
-        callSite: "skillCategoryInference",
-        max_tokens: 1024,
-      },
-    },
-  );
-
-  const text = extractAllText(response);
-
-  const svgMatch = text.match(/<svg[\s\S]*<\/svg>/i);
-  if (!svgMatch) {
-    throw new Error("No <svg> element found in response");
-  }
-
-  return svgMatch[0];
-}
-
-/**
- * Synchronously read a cached icon if it exists on disk. Returns undefined if not cached yet.
- */
-export function readCachedSkillIcon(directoryPath: string): string | undefined {
-  const iconPath = join(directoryPath, "icon.svg");
-  if (existsSync(iconPath)) {
-    try {
-      return readFileSync(iconPath, "utf-8");
-    } catch {
-      return undefined;
-    }
-  }
-  return undefined;
-}
-
-export async function ensureSkillIcon(
-  directoryPath: string,
-  name: string,
-  description: string,
-): Promise<string | undefined> {
-  const iconPath = join(directoryPath, "icon.svg");
-
-  if (existsSync(iconPath)) {
-    try {
-      return readFileSync(iconPath, "utf-8");
-    } catch {
-      log.warn({ iconPath }, "Failed to read existing icon.svg");
-      return undefined;
-    }
-  }
-
-  try {
-    const svg = await generateSkillIcon(name, description);
-    try {
-      writeFileSync(iconPath, svg, "utf-8");
-      log.info({ iconPath }, "Generated skill icon");
-    } catch (writeErr) {
-      log.warn(
-        { err: writeErr, iconPath },
-        "Failed to cache icon.svg (returning generated icon anyway)",
-      );
-    }
-    return svg;
-  } catch (err) {
-    log.warn({ err, iconPath }, "Failed to generate skill icon");
-    return undefined;
-  }
-}

package/src/config/types.ts

@@ -1,6 +1,3 @@
-export type {
-  AssistantConfig,
-  ContextWindowConfig,
-  MemoryConfig,
-  RateLimitConfig,
-} from "./schema.js";
+export type { AssistantConfig, ContextWindowConfig } from "./schema.js";
+export type { MemoryConfig } from "./schemas/memory.js";
+export type { RateLimitConfig } from "./schemas/timeouts.js";

package/src/contacts/contact-store.ts

@@ -839,23 +839,6 @@ export function findContactChannel(params: {
   return null;
 }
 
-/**
- * Find the guardian contact regardless of channel.
- * Returns the first contact with role='guardian', or null if none exists.
- */
-export function findGuardianContact(): ContactWithChannels | null {
-  const db = getDb();
-  const row = db
-    .select()
-    .from(contacts)
-    .where(eq(contacts.role, "guardian"))
-    .orderBy(asc(contacts.createdAt))
-    .limit(1)
-    .get();
-  if (!row) return null;
-  return withChannels(parseContact(row));
-}
-
 /**
  * Find the guardian contact and their specific channel entry for a given channel type.
  * This is the contacts-based equivalent of getGuardianBinding(assistantId, channel).
@@ -978,19 +961,6 @@ export function updateChannelStatus(
   return parseChannel(existing);
 }
 
-/**
- * Update the lastSeenAt timestamp on a contact channel by its primary key.
- * Optimized for the hot path — single UPDATE with no prior SELECT.
- */
-export function updateChannelLastSeenById(channelId: string): void {
-  const db = getDb();
-  const now = Date.now();
-  db.update(contactChannels)
-    .set({ lastSeenAt: now, updatedAt: now })
-    .where(eq(contactChannels.id, channelId))
-    .run();
-}
-
 /**
  * Update a guardian contact's principalId and its channel's identity fields.
  * Used for healing guardian binding drift when the JWT principal no longer
@@ -1054,23 +1024,6 @@ export function updateContactPrincipalAndChannel(
   return true;
 }
 
-/**
- * Atomically increment interactionCount and set lastInteraction on a contact channel.
- * Optimized for the hot path — single UPDATE with no prior SELECT.
- */
-export function updateChannelInteraction(channelId: string): void {
-  const db = getDb();
-  const now = Date.now();
-  db.update(contactChannels)
-    .set({
-      lastInteraction: now,
-      interactionCount: sql`${contactChannels.interactionCount} + 1`,
-      updatedAt: now,
-    })
-    .where(eq(contactChannels.id, channelId))
-    .run();
-}
-
 // ── Assistant Contact Metadata ──────────────────────────────────────
 
 function parseAssistantMetadata(