@vellumai/assistant 0.7.2 → 0.8.0

package/src/config/schemas/llm.ts

@@ -70,6 +70,8 @@ export const LLMCallSiteEnum = z.enum([
   "inference",
   "feedEventCopy",
   "trustRuleSuggestion",
+  "proactiveArtifactDecision",
+  "proactiveArtifactBuild",
 ]);
 export type LLMCallSite = z.infer<typeof LLMCallSiteEnum>;
 

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

@@ -149,6 +149,19 @@ export const MemoryCleanupConfigSchema = z
       .describe(
         "Retention period for LLM request/response logs in milliseconds (null keeps forever, 0 prunes immediately)",
       ),
+    traceEventRetentionDays: z
+      .number({
+        error: "memory.cleanup.traceEventRetentionDays must be a number",
+      })
+      .int("memory.cleanup.traceEventRetentionDays must be an integer")
+      .nonnegative(
+        "memory.cleanup.traceEventRetentionDays must be non-negative",
+      )
+      .max(365, "memory.cleanup.traceEventRetentionDays must be <= 365 days")
+      .default(3)
+      .describe(
+        "Number of days to retain trace events before cleanup (0 disables pruning)",
+      ),
   })
   .describe("Automatic memory cleanup and garbage collection settings");
 

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

@@ -7,6 +7,33 @@ import { z } from "zod";
  */
 const WEIGHT_SUM_TOLERANCE = 0.001;
 
+/**
+ * Default cross-encoder model for memory v2 reranking.
+ * `Alibaba-NLP/gte-reranker-modernbert-base` (149M, Apache-2.0) — 2025
+ * ModernBERT-backbone reranker; smaller, newer, and cleaner-licensed than
+ * the bge family while matching or beating their retrieval-benchmark scores.
+ * Has ONNX exports at the standard `onnx/model.onnx` path.
+ */
+const DEFAULT_RERANK_MODEL = "Alibaba-NLP/gte-reranker-modernbert-base";
+
+/**
+ * ONNX weight precision passed to `@huggingface/transformers`. Sourced from
+ * transformers.js's supported `dtype` values; `q8` (int8) is ~3× faster than
+ * `fp32` on CPU with negligible reranker accuracy loss. Single source of
+ * truth for both the schema enum and the `LocalRerankBackend` type.
+ */
+export const RerankDtypeEnum = z.enum([
+  "fp32",
+  "fp16",
+  "q8",
+  "int8",
+  "uint8",
+  "q4",
+  "bnb4",
+  "q4f16",
+]);
+export type RerankDtype = z.infer<typeof RerankDtypeEnum>;
+
 /**
  * Memory v2 (concept-page activation model) configuration.
  *
@@ -21,9 +48,9 @@ export const MemoryV2ConfigSchema = z
   .object({
     enabled: z
       .boolean({ error: "memory.v2.enabled must be a boolean" })
-      .default(false)
+      .default(true)
       .describe(
-        "Whether the v2 memory subsystem (concept-page activation model) is enabled. Independent of the memory-v2-enabled feature flag — both must be true for v2 to run.",
+        "Whether the v2 memory subsystem (concept-page activation model) is enabled.",
       ),
     sweep_enabled: z
       .boolean({ error: "memory.v2.sweep_enabled must be a boolean" })
@@ -83,9 +110,9 @@ export const MemoryV2ConfigSchema = z
       .number({ error: "memory.v2.top_k must be a number" })
       .int("memory.v2.top_k must be an integer")
       .positive("memory.v2.top_k must be a positive integer")
-      .default(20)
+      .default(25)
       .describe(
-        "Number of top-activation concept pages considered for injection per turn",
+        "Number of top-activation entries (concept pages and skills combined) considered for injection per turn. Skills are scored alongside concepts in the same pool; this cap covers both.",
       ),
     ann_candidate_limit: z
       .number({ error: "memory.v2.ann_candidate_limit must be a number" })
@@ -96,14 +123,6 @@ export const MemoryV2ConfigSchema = z
       .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()
-      .nonnegative()
-      .default(5)
-      .describe(
-        "Cap on the per-turn skill-autoinjection slate rendered in `### Skills You Can Use`. 0 disables skill autoinjection without code changes.",
-      ),
     epsilon: z
       .number({ error: "memory.v2.epsilon must be a number" })
       .min(0, "memory.v2.epsilon must be >= 0")
@@ -192,6 +211,51 @@ export const MemoryV2ConfigSchema = z
       .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.",
       ),
+    rerank: z
+      .object({
+        enabled: z
+          .boolean()
+          .default(false)
+          .describe(
+            "Whether to apply cross-encoder reranking as an additive A_o boost on the user + assistant channels. Disabled by default — opt in once measured.",
+          ),
+        top_k: z
+          .number()
+          .int()
+          .positive()
+          .max(200)
+          .default(50)
+          .describe(
+            "Number of candidates from the top of the pre-rerank-A_o pool to send through the reranker. Tail candidates contribute zero rerank boost and keep their pure fused activation.",
+          ),
+        alpha: z
+          .number()
+          .min(0)
+          .max(1)
+          .default(0.3)
+          .describe(
+            "Per-channel rerank weight: each top-K slug gets `alpha · normalized_rerank` added to A_o weighted by `c_user` (user channel) or `c_assistant` (assistant channel). Top reranker hit can lift A_o by up to `(c_user + c_assistant) · alpha`; bottom of top_k stays roughly unchanged.",
+          ),
+        model: z
+          .string()
+          .default(DEFAULT_RERANK_MODEL)
+          .describe(
+            "HuggingFace model id for the cross-encoder. Must have an ONNX export reachable from huggingface.co/<model>/resolve/main/onnx/model.onnx.",
+          ),
+        dtype: RerankDtypeEnum.default("q8").describe(
+          "ONNX weight precision passed to `@huggingface/transformers`. `q8` (int8) is ~3× faster than `fp32` on CPU with negligible reranker accuracy loss. The worker fails to spawn if the configured model has no matching quantized export — `reranker.ts` then falls back to pure fused scores for the turn.",
+        ),
+      })
+      .default({
+        enabled: false,
+        top_k: 50,
+        alpha: 0.3,
+        model: DEFAULT_RERANK_MODEL,
+        dtype: "q8",
+      })
+      .describe(
+        "Cross-encoder rerank configuration. When enabled, picks the top-K candidates by pre-rerank A_o, runs the cross-encoder once per channel (user, assistant) on that unified set, and adds an alpha-weighted normalized boost to A_o for each scored slug.",
+      ),
   })
   .describe(
     "Memory v2 — concept-page activation model with hourly LLM-driven consolidation",

package/src/config/schemas/platform.ts

@@ -1,5 +1,41 @@
 import { z } from "zod";
 
+const IANA_TIMEZONE_IDENTIFIER_RE =
+  /^(?:UTC|[A-Za-z][A-Za-z0-9_+-]*(?:\/[A-Za-z0-9_+-]+)+)$/;
+
+function canonicalizeIanaTimezone(timezone: string): string | null {
+  const trimmed = timezone.trim();
+  if (trimmed.length === 0) {
+    return "";
+  }
+  if (!IANA_TIMEZONE_IDENTIFIER_RE.test(trimmed)) {
+    return null;
+  }
+  try {
+    return new Intl.DateTimeFormat("en-US", {
+      timeZone: trimmed,
+    }).resolvedOptions().timeZone;
+  } catch {
+    return null;
+  }
+}
+
+function timezoneConfigField(path: string) {
+  return z
+    .string({ error: `${path} must be a string` })
+    .transform((value, ctx) => {
+      const canonical = canonicalizeIanaTimezone(value);
+      if (canonical === null) {
+        ctx.addIssue({
+          code: "custom",
+          message: `${path} must be a valid IANA timezone identifier or an empty string`,
+        });
+        return z.NEVER;
+      }
+      return canonical;
+    });
+}
+
 export const PlatformConfigSchema = z
   .object({
     baseUrl: z
@@ -56,11 +92,15 @@ export const DaemonConfigSchema = z
 
 export const UiConfigSchema = z
   .object({
-    userTimezone: z
-      .string({ error: "ui.userTimezone must be a string" })
+    userTimezone: timezoneConfigField("ui.userTimezone")
+      .optional()
+      .describe(
+        "Manual IANA timezone override used for assistant temporal grounding and date/time display (e.g. 'America/New_York'). Use an empty string to clear the setting.",
+      ),
+    detectedTimezone: timezoneConfigField("ui.detectedTimezone")
       .optional()
       .describe(
-        "IANA timezone identifier for displaying dates and times (e.g. 'America/New_York')",
+        "IANA timezone identifier detected from the client environment for assistant temporal grounding when no manual override is configured (e.g. 'America/New_York'). Use an empty string to clear the setting.",
       ),
   })
   .describe(

package/src/config/schemas/services.ts

@@ -72,6 +72,22 @@ const TwitterOAuthServiceSchema = BaseServiceSchema.extend({
   mode: ServiceModeSchema.default("your-own"),
 });
 
+const AsanaOAuthServiceSchema = BaseServiceSchema.extend({
+  mode: ServiceModeSchema.default("your-own"),
+});
+
+const TodoistOAuthServiceSchema = BaseServiceSchema.extend({
+  mode: ServiceModeSchema.default("your-own"),
+});
+
+const DiscordOAuthServiceSchema = BaseServiceSchema.extend({
+  mode: ServiceModeSchema.default("your-own"),
+});
+
+const HubspotOAuthServiceSchema = BaseServiceSchema.extend({
+  mode: ServiceModeSchema.default("your-own"),
+});
+
 /**
  * `services.meet.host.*` — daemon-side knobs for the externalized meet-join
  * skill process. Kept narrow: only the values the daemon reads before the
@@ -140,6 +156,18 @@ export const ServicesSchema = z.object({
   "twitter-oauth": TwitterOAuthServiceSchema.default(
     TwitterOAuthServiceSchema.parse({}),
   ),
+  "asana-oauth": AsanaOAuthServiceSchema.default(
+    AsanaOAuthServiceSchema.parse({}),
+  ),
+  "todoist-oauth": TodoistOAuthServiceSchema.default(
+    TodoistOAuthServiceSchema.parse({}),
+  ),
+  "discord-oauth": DiscordOAuthServiceSchema.default(
+    DiscordOAuthServiceSchema.parse({}),
+  ),
+  "hubspot-oauth": HubspotOAuthServiceSchema.default(
+    HubspotOAuthServiceSchema.parse({}),
+  ),
   meet: MeetDaemonServiceSchema.default(MeetDaemonServiceSchema.parse({})),
 });
 export type Services = z.infer<typeof ServicesSchema>;

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

@@ -1,3 +1,6 @@
+import { PROVIDER_CATALOG } from "../providers/model-catalog.js";
+import { resolveModelIntent } from "../providers/model-intents.js";
+import type { ModelIntent } from "../providers/types.js";
 import { loadRawConfig, saveRawConfig } from "./loader.js";
 import {
   DEFAULT_CONTEXT_WINDOW_MAX_INPUT_TOKENS,
@@ -5,41 +8,82 @@ import {
 } 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.
+ * Template for a daemon-managed inference profile. The profile's model is
+ * resolved at seed time from `PROVIDER_MODEL_INTENTS` so the catalog stays the
+ * single source of truth for "which model does this intent map to?".
  */
-const MANAGED_PROFILE_SEED_DATA: Record<string, ProfileEntry> = {
+type ManagedProfileTemplate = Omit<ProfileEntry, "provider" | "model"> & {
+  intent: ModelIntent;
+};
+
+/**
+ * Anthropic-managed profiles. Always seeded so users can target Anthropic via
+ * their own key, even when the resolved default provider is something else.
+ */
+const ANTHROPIC_PROFILE_TEMPLATES: Record<string, ManagedProfileTemplate> = {
   balanced: {
+    intent: "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": {
+    intent: "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": {
+    intent: "latency-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 },
+  },
+};
+
+/**
+ * Custom-provider profile templates. Materialized at seed time when the
+ * resolved default provider is non-Anthropic, using `resolveModelIntent` to
+ * pick the model.
+ */
+const CUSTOM_PROFILE_TEMPLATES: Record<string, ManagedProfileTemplate> = {
+  "custom-balanced": {
+    intent: "balanced",
+    source: "user",
+    label: "Balanced (Custom Provider)",
+    description: "Good balance of quality, cost, and speed",
+    maxTokens: 16000,
+    effort: "high",
+    thinking: { enabled: true, streamThinking: true },
+    contextWindow: { maxInputTokens: DEFAULT_CONTEXT_WINDOW_MAX_INPUT_TOKENS },
+  },
+  "custom-quality-optimized": {
+    intent: "quality-optimized",
+    source: "user",
+    label: "Quality (Custom Provider)",
+    description: "Best results with the most capable model",
+    maxTokens: 32000,
+    effort: "max",
+    thinking: { enabled: true, streamThinking: true },
+    contextWindow: { maxInputTokens: DEFAULT_CONTEXT_WINDOW_MAX_INPUT_TOKENS },
+  },
+  "custom-cost-optimized": {
+    intent: "latency-optimized",
+    source: "user",
+    label: "Speed (Custom Provider)",
+    description: "Fastest responses at lower cost",
     maxTokens: 8192,
     effort: "low",
     thinking: { enabled: false, streamThinking: false },
@@ -48,26 +92,47 @@ const MANAGED_PROFILE_SEED_DATA: Record<string, ProfileEntry> = {
 };
 
 export const MANAGED_PROFILE_NAMES = new Set(
-  Object.keys(MANAGED_PROFILE_SEED_DATA),
+  Object.keys(ANTHROPIC_PROFILE_TEMPLATES),
 );
 
+const SEEDED_PROFILE_NAMES = new Set([
+  ...Object.keys(ANTHROPIC_PROFILE_TEMPLATES),
+  ...Object.keys(CUSTOM_PROFILE_TEMPLATES),
+]);
+
+const KNOWN_PROVIDERS = new Set(PROVIDER_CATALOG.map((entry) => entry.id));
+
+export type SeedInferenceProfilesOptions = {
+  /**
+   * Managed profile names supplied by the platform/default overlay for this
+   * startup. Those entries are already on disk by the time seeding runs and
+   * should remain authoritative for this boot.
+   */
+  preserveProfileNames?: Iterable<string>;
+  preserveActiveProfile?: boolean;
+};
+
 /**
  * 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.
+ * Called on every daemon startup after workspace migrations and default-config
+ * overlay merge, but before the first `loadConfig()`. The 3 Anthropic-managed
+ * profiles (`balanced`, `quality-optimized`, `cost-optimized`) are always
+ * written so users can target Anthropic via their own key. When the resolved
+ * default provider is non-Anthropic, the 3 `custom-*` profiles are also
+ * materialized using `resolveModelIntent` against that provider, and
+ * `custom-balanced` becomes the active profile for fresh hatches.
  *
- * 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.
+ * Default-config overlays can provide their own profile fragments and active
+ * profile. Lifecycle passes those explicit fields in `options`, letting local
+ * hatches still receive managed defaults while platform-owned profile choices
+ * remain authoritative.
  */
-export function seedInferenceProfiles(): void {
-  if (process.env.VELLUM_DEFAULT_WORKSPACE_CONFIG_PATH) return;
-
+export function seedInferenceProfiles(
+  options: SeedInferenceProfilesOptions = {},
+): void {
   const config = loadRawConfig();
+  const preservedProfileNames = new Set(options.preserveProfileNames ?? []);
 
   if (config.llm == null || typeof config.llm !== "object") {
     config.llm = {};
@@ -79,25 +144,135 @@ export function seedInferenceProfiles(): void {
   }
   const profiles = llm.profiles as Record<string, Record<string, unknown>>;
 
-  for (const [name, seed] of Object.entries(MANAGED_PROFILE_SEED_DATA)) {
-    profiles[name] = { ...seed };
+  const requestedProvider =
+    readString(readObject(llm.default)?.provider) ?? "anthropic";
+  const isKnownProvider = KNOWN_PROVIDERS.has(requestedProvider);
+  const resolvedProvider: NonNullable<ProfileEntry["provider"]> =
+    isKnownProvider
+      ? (requestedProvider as NonNullable<ProfileEntry["provider"]>)
+      : "anthropic";
+  const isAnthropicDefault = resolvedProvider === "anthropic";
+
+  // Persist the resolved provider when the overlay supplied an unrecognized
+  // value, so the on-disk config doesn't keep emitting Zod warnings for
+  // `unknownprov` on every load.
+  if (!isKnownProvider) {
+    const defaultBlock = (readObject(llm.default) ?? {}) as Record<
+      string,
+      unknown
+    >;
+    defaultBlock.provider = resolvedProvider;
+    llm.default = defaultBlock;
+  }
+
+  for (const [name, template] of Object.entries(ANTHROPIC_PROFILE_TEMPLATES)) {
+    if (preservedProfileNames.has(name)) continue;
+    // Preserve a previously overlay-supplied profile whose provider matches
+    // the resolved default — that's the platform-managed case where the
+    // overlay file has already been consumed and archived. Only valid for
+    // non-Anthropic resolutions; when the default is Anthropic the daemon
+    // owns these names and re-seeds with Anthropic data so a stale openai
+    // `balanced` doesn't keep routing through the wrong provider after a
+    // re-hatch back to Anthropic.
+    const existing = readObject(profiles[name]);
+    const existingProvider = readString(existing?.provider);
+    if (
+      existing !== null &&
+      !isAnthropicDefault &&
+      existingProvider === resolvedProvider
+    ) {
+      continue;
+    }
+    profiles[name] = materializeProfile(template, "anthropic");
+  }
+
+  if (!isAnthropicDefault) {
+    for (const [name, template] of Object.entries(CUSTOM_PROFILE_TEMPLATES)) {
+      if (preservedProfileNames.has(name)) continue;
+      if (readObject(profiles[name]) !== null) continue;
+      profiles[name] = materializeProfile(template, resolvedProvider);
+    }
+  }
+
+  const requestedActiveProfile = readString(llm.activeProfile);
+  const requestedActiveEntry =
+    requestedActiveProfile !== undefined
+      ? readObject(profiles[requestedActiveProfile])
+      : null;
+  const requestedActiveExists = requestedActiveEntry !== null;
+  const shouldPreserveActiveProfile =
+    options.preserveActiveProfile === true && requestedActiveExists;
+
+  // Decide whether the existing active profile is still appropriate. A managed
+  // profile whose provider no longer matches the resolved default goes stale
+  // (e.g. re-hatching anthropic→openai leaves `balanced` pointing at anthropic;
+  // re-hatching openai→anthropic leaves `custom-balanced` pointing at openai).
+  // Either direction should land the user on the new default's `balanced`
+  // counterpart rather than routing the main agent to a stale provider.
+  // User-created profiles are left alone — those are the user's choice.
+  let keepActiveProfile = shouldPreserveActiveProfile;
+  if (!keepActiveProfile && requestedActiveExists) {
+    const isSeededName = SEEDED_PROFILE_NAMES.has(requestedActiveProfile!);
+    const activeProvider = readString(requestedActiveEntry?.provider);
+    const managedActiveProviderMismatch =
+      isSeededName && activeProvider !== resolvedProvider;
+    keepActiveProfile = !managedActiveProviderMismatch;
   }
 
-  // Reset to the default managed profile when the current value is missing.
-  if (
-    typeof llm.activeProfile !== "string" ||
-    !(llm.activeProfile in profiles)
-  ) {
-    llm.activeProfile = "balanced";
+  let activeProfileName: string;
+  if (keepActiveProfile) {
+    activeProfileName = requestedActiveProfile!;
+  } else {
+    activeProfileName = isAnthropicDefault ? "balanced" : "custom-balanced";
+    llm.activeProfile = activeProfileName;
+  }
+
+  // Sync `llm.default.model` to the active profile's model so the providers
+  // registry sees a coherent provider/model pair. Only writes when the on-disk
+  // default model is missing or unambiguously belongs to a *different*
+  // provider's catalog (e.g. `claude-opus-4-7` paired with `provider: openai`).
+  // A user-supplied model not listed in any provider's catalog is preserved —
+  // ollama and openrouter expose far more models than `PROVIDER_CATALOG` lists,
+  // and silently overwriting `codellama`/`phi3`/etc. on every restart would
+  // break those users' configs. Skipped when the overlay owns the active
+  // profile (platform mode).
+  if (!shouldPreserveActiveProfile) {
+    const activeEntry = readObject(profiles[activeProfileName]);
+    const activeModel = readString(activeEntry?.model);
+    if (activeModel !== undefined) {
+      const defaultBlock = (readObject(llm.default) ?? {}) as Record<
+        string,
+        unknown
+      >;
+      const currentModel = readString(defaultBlock.model);
+      const modelBelongsToOtherProvider =
+        currentModel !== undefined &&
+        PROVIDER_CATALOG.some(
+          (p) =>
+            p.id !== resolvedProvider &&
+            p.models.some((m) => m.id === currentModel),
+        );
+      const shouldOverwriteDefaultModel =
+        currentModel === undefined || modelBelongsToOtherProvider;
+      if (shouldOverwriteDefaultModel) {
+        defaultBlock.model = activeModel;
+        llm.default = defaultBlock;
+      }
+    }
   }
 
   const profileOrder = Array.isArray(llm.profileOrder)
     ? (llm.profileOrder as string[])
     : [];
   const orderSet = new Set(profileOrder);
-  for (const name of MANAGED_PROFILE_NAMES) {
+  const seededOrder = [
+    ...Object.keys(ANTHROPIC_PROFILE_TEMPLATES),
+    ...(isAnthropicDefault ? [] : Object.keys(CUSTOM_PROFILE_TEMPLATES)),
+  ];
+  for (const name of seededOrder) {
     if (!orderSet.has(name)) {
       profileOrder.push(name);
+      orderSet.add(name);
     }
   }
   llm.profileOrder = profileOrder;
@@ -115,3 +290,25 @@ export function seedInferenceProfiles(): void {
 
   saveRawConfig(config);
 }
+
+function materializeProfile(
+  template: ManagedProfileTemplate,
+  provider: NonNullable<ProfileEntry["provider"]>,
+): ProfileEntry {
+  const { intent, ...rest } = template;
+  return {
+    ...rest,
+    provider,
+    model: resolveModelIntent(provider, intent),
+  };
+}
+
+function readObject(value: unknown): Record<string, unknown> | null {
+  return value !== null && typeof value === "object" && !Array.isArray(value)
+    ? (value as Record<string, unknown>)
+    : null;
+}
+
+function readString(value: unknown): string | undefined {
+  return typeof value === "string" && value.length > 0 ? value : undefined;
+}

package/src/contacts/contact-store.ts

@@ -704,31 +704,6 @@ export function mergeContacts(
   return getContactInternal(keepId)!;
 }
 
-/**
- * Delete a contact by ID. Guardians cannot be deleted as a safety guard.
- * Associated contactChannels and assistantContactMetadata rows are
- * cascade-deleted by the DB schema's onDelete constraints.
- */
-export function deleteContact(
-  contactId: string,
-): "ok" | "not_found" | "is_guardian" {
-  const db = getDb();
-
-  const contact = db
-    .select()
-    .from(contacts)
-    .where(eq(contacts.id, contactId))
-    .get();
-
-  if (!contact) return "not_found";
-  if (contact.role === "guardian") return "is_guardian";
-
-  db.delete(contacts).where(eq(contacts.id, contactId)).run();
-
-  emitContactChange();
-  return "ok";
-}
-
 /**
  * Find a contact by a specific channel address. Returns null if not found.
  */

package/src/daemon/__tests__/conversation-lifecycle-auto-analyze.test.ts

@@ -56,6 +56,16 @@ let autoAnalyzeEnabled = true;
 // `disposeConversation` must skip the `graph_extract` enqueue.
 const autoAnalysisConversations = new Set<string>();
 
+// Toggles the `memory.v2.enabled` flag the disposal code reads via
+// `getConfig()`. Defaults to false so the bulk of the suite — which asserts
+// v1 graph_extract still fires — keeps its semantics. The dedicated v2 cases
+// flip this to true.
+let v2Enabled = false;
+
+mock.module("../../config/loader.js", () => ({
+  getConfig: () => ({ memory: { v2: { enabled: v2Enabled } } }),
+}));
+
 mock.module("../../memory/auto-analysis-guard.js", () => ({
   AUTO_ANALYSIS_SOURCE: "auto-analysis",
   isAutoAnalysisConversation: (conversationId: string) =>
@@ -160,6 +170,7 @@ describe("disposeConversation — auto-analysis enqueue", () => {
     autoAnalyzeCalls.length = 0;
     autoAnalyzeEnabled = true;
     autoAnalysisConversations.clear();
+    v2Enabled = false;
   });
 
   test("guardian conversation with auto-analyze ON — enqueues both graph_extract and conversation_analyze (via helper)", () => {
@@ -313,4 +324,25 @@ describe("disposeConversation — auto-analysis enqueue", () => {
     }));
     autoAnalyzeEnabled = originalEnabled;
   });
+
+  test("memory v2 enabled — graph_extract enqueue is suppressed (auto-analysis still runs)", () => {
+    // Under memory v2, the v1 graph has no readers (retrieval is bypassed at
+    // conversation-graph-memory.ts), so producing extraction jobs just fills
+    // the queue with stale work. Auto-analysis is orthogonal and must keep
+    // running.
+    v2Enabled = true;
+    const ctx = makeDisposeContext({
+      conversationId: "conv-v2-on",
+      trustClass: "guardian",
+    });
+
+    disposeConversation(ctx);
+
+    expect(memoryJobCalls).toHaveLength(0);
+    expect(autoAnalyzeCalls).toHaveLength(1);
+    expect(autoAnalyzeCalls[0]).toEqual({
+      conversationId: "conv-v2-on",
+      trigger: "lifecycle",
+    });
+  });
 });