@vellumai/assistant 0.6.6 → 0.7.1

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

@@ -0,0 +1,185 @@
+import { z } from "zod";
+
+/**
+ * Tolerance for floating-point comparisons of weight sums. Using 0.001 lets
+ * users specify weights to three decimal places without spurious rejections,
+ * while still catching obvious mis-sums.
+ */
+const WEIGHT_SUM_TOLERANCE = 0.001;
+
+/**
+ * Memory v2 (concept-page activation model) configuration.
+ *
+ * Activation weights (`d`, `c_user`, `c_assistant`, `c_now`) must sum to 1.0
+ * because they form a convex combination in the per-turn activation formula:
+ *   A_o = d·prev + c_user·sim_u + c_assistant·sim_a + c_now·sim_n
+ *
+ * Hybrid retrieval weights (`dense_weight`, `sparse_weight`) must likewise
+ * sum to 1.0 since they fuse normalized dense and sparse similarity scores.
+ */
+export const MemoryV2ConfigSchema = z
+  .object({
+    enabled: z
+      .boolean({ error: "memory.v2.enabled must be a boolean" })
+      .default(false)
+      .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.",
+      ),
+    sweep_enabled: z
+      .boolean({ error: "memory.v2.sweep_enabled must be a boolean" })
+      .default(false)
+      .describe(
+        "Whether the v2 idle-debounced sweep job is enabled. Off by default — `remember()` is the primary capture path; opt in only when the model is missing entries the sweep would have caught.",
+      ),
+    d: z
+      .number({ error: "memory.v2.d must be a number" })
+      .min(0, "memory.v2.d must be >= 0")
+      .max(1, "memory.v2.d must be <= 1")
+      .default(0.3)
+      .describe(
+        "Decay weight on prior activation in the per-turn activation formula",
+      ),
+    c_user: z
+      .number({ error: "memory.v2.c_user must be a number" })
+      .min(0, "memory.v2.c_user must be >= 0")
+      .max(1, "memory.v2.c_user must be <= 1")
+      .default(0.3)
+      .describe(
+        "Weight on similarity to the latest user message in the per-turn activation formula",
+      ),
+    c_assistant: z
+      .number({ error: "memory.v2.c_assistant must be a number" })
+      .min(0, "memory.v2.c_assistant must be >= 0")
+      .max(1, "memory.v2.c_assistant must be <= 1")
+      .default(0.2)
+      .describe(
+        "Weight on similarity to the latest assistant message in the per-turn activation formula",
+      ),
+    c_now: z
+      .number({ error: "memory.v2.c_now must be a number" })
+      .min(0, "memory.v2.c_now must be >= 0")
+      .max(1, "memory.v2.c_now must be <= 1")
+      .default(0.2)
+      .describe(
+        "Weight on similarity to NOW context (essentials/threads/recent) in the per-turn activation formula",
+      ),
+    k: z
+      .number({ error: "memory.v2.k must be a number" })
+      .min(0, "memory.v2.k must be >= 0")
+      .max(1, "memory.v2.k must be <= 1")
+      .default(0.5)
+      .describe(
+        "Spreading-activation propagation coefficient — fraction of own activation that flows to neighbors per hop",
+      ),
+    hops: z
+      .number({ error: "memory.v2.hops must be a number" })
+      .int("memory.v2.hops must be an integer")
+      .nonnegative("memory.v2.hops must be non-negative")
+      .default(2)
+      .describe(
+        "Maximum BFS distance for spreading activation across the concept graph",
+      ),
+    top_k: 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)
+      .describe(
+        "Number of top-activation concept pages considered for injection per turn",
+      ),
+    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")
+      .max(1, "memory.v2.epsilon must be <= 1")
+      .default(0.01)
+      .describe(
+        "Activation cutoff — slugs with activation <= epsilon are dropped from the persisted state",
+      ),
+    dense_weight: 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)
+      .describe(
+        "Weight on dense (cosine) similarity in the hybrid retrieval 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)
+      .describe(
+        "Weight on sparse (BM25-style) similarity in the hybrid retrieval score",
+      ),
+    consolidation_interval_hours: z
+      .number({
+        error: "memory.v2.consolidation_interval_hours must be a number",
+      })
+      .int("memory.v2.consolidation_interval_hours must be an integer")
+      .positive(
+        "memory.v2.consolidation_interval_hours must be a positive integer",
+      )
+      .default(4)
+      .describe(
+        "Hours between scheduled consolidation runs that synthesize buffered memories into concept pages",
+      ),
+    max_page_chars: z
+      .number({ error: "memory.v2.max_page_chars must be a number" })
+      .int("memory.v2.max_page_chars must be an integer")
+      .positive("memory.v2.max_page_chars must be a positive integer")
+      .default(5000)
+      .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",
+  )
+  .superRefine((config, ctx) => {
+    const activationSum =
+      config.d + config.c_user + config.c_assistant + config.c_now;
+    if (Math.abs(activationSum - 1.0) >= WEIGHT_SUM_TOLERANCE) {
+      const message = `memory.v2 activation weights (d + c_user + c_assistant + c_now) must sum to 1.0 (got ${activationSum.toFixed(4)})`;
+      // Emit on every contributing field so validateWithSchema's
+      // delete-and-retry repair can strip the offending values and fall
+      // back to the documented defaults rather than wiping the whole v2
+      // block.
+      for (const path of ["d", "c_user", "c_assistant", "c_now"] as const) {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          path: [path],
+          message,
+        });
+      }
+    }
+    const hybridSum = config.dense_weight + config.sparse_weight;
+    if (Math.abs(hybridSum - 1.0) >= WEIGHT_SUM_TOLERANCE) {
+      const message = `memory.v2 hybrid weights (dense_weight + sparse_weight) must sum to 1.0 (got ${hybridSum.toFixed(4)})`;
+      for (const path of ["dense_weight", "sparse_weight"] as const) {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          path: [path],
+          message,
+        });
+      }
+    }
+  });
+
+export type MemoryV2Config = z.infer<typeof MemoryV2ConfigSchema>;

package/src/config/schemas/memory.ts

@@ -15,6 +15,7 @@ import {
   MemorySegmentationConfigSchema,
   QdrantConfigSchema,
 } from "./memory-storage.js";
+import { MemoryV2ConfigSchema } from "./memory-v2.js";
 
 export const MemoryConfigSchema = z
   .object({
@@ -45,6 +46,7 @@ export const MemoryConfigSchema = z
     summarization: MemorySummarizationConfigSchema.default(
       MemorySummarizationConfigSchema.parse({}),
     ),
+    v2: MemoryV2ConfigSchema.default(MemoryV2ConfigSchema.parse({})),
   })
   .describe(
     "Long-term memory system — stores, retrieves, and manages persistent knowledge across conversations",

package/src/config/schemas/security.ts

@@ -1,49 +1,11 @@
 import { z } from "zod";
 
-const VALID_SECRET_ACTIONS = ["redact", "warn", "block", "prompt"] as const;
-const VALID_PERMISSIONS_MODES = ["strict", "workspace"] as const;
-
-export { VALID_PERMISSIONS_MODES, VALID_SECRET_ACTIONS };
-
-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)
@@ -56,72 +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 const PermissionsConfigSchema = z
-  .object({
-    mode: z
-      .enum(VALID_PERMISSIONS_MODES, {
-        error: `permissions.mode must be one of: ${VALID_PERMISSIONS_MODES.join(
-          ", ",
-        )}`,
-      })
-      .default("workspace")
-      .describe(
-        "Permission mode — 'strict' requires explicit approval for all operations, 'workspace' allows operations within the workspace",
-      ),
-    hostAccess: z
-      .boolean({
-        error: "permissions.hostAccess must be a boolean",
-      })
-      .default(false)
-      .describe(
-        "Whether the assistant can execute commands on the host machine without prompting",
-      ),
-    autoApproveUpTo: z
-      .union([
-        z.enum(["none", "low", "medium", "high"], {
-          error:
-            "permissions.autoApproveUpTo must be one of: none, low, medium, high",
-        }),
-        z.object({
-          conversation: z
-            .enum(["none", "low", "medium", "high"])
-            .default("low")
-            .describe(
-              "Threshold for interactive conversation sessions (default: low)",
-            ),
-          background: z
-            .enum(["none", "low", "medium", "high"])
-            .default("medium")
-            .describe(
-              "Threshold for non-interactive guardian sessions (default: medium)",
-            ),
-          headless: z
-            .enum(["none", "low", "medium", "high"])
-            .default("none")
-            .describe(
-              "Threshold for non-interactive non-guardian sessions (default: none)",
-            ),
-        }),
-      ])
-      .default({ conversation: "low", background: "medium", headless: "none" })
-      .describe(
-        "Auto-approve tools at or below this risk level without prompting. " +
-          "Accepts a scalar ('none', 'low', 'medium', 'high') applied to all contexts, " +
-          "or an object with per-context overrides: { conversation, background, headless }.",
-      ),
-  })
-  .describe("Permission enforcement mode for tool operations");
-
 export type SecretDetectionConfig = z.infer<typeof SecretDetectionConfigSchema>;
-export type PermissionsConfig = z.infer<typeof PermissionsConfigSchema>;

package/src/config/schemas/services.ts

@@ -3,7 +3,7 @@ import { z } from "zod";
 import { SttServiceSchema } from "./stt.js";
 import { TtsServiceSchema } from "./tts.js";
 
-export const ServiceModeSchema = z.enum(["managed", "your-own"]);
+const ServiceModeSchema = z.enum(["managed", "your-own"]);
 export type ServiceMode = z.infer<typeof ServiceModeSchema>;
 
 export const VALID_INFERENCE_PROVIDERS = [
@@ -15,15 +15,15 @@ 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",
 ] as const;
 
-export const BaseServiceSchema = z.object({
+const BaseServiceSchema = z.object({
   mode: ServiceModeSchema.default("your-own"),
 });
 export type BaseService = z.infer<typeof BaseServiceSchema>;
@@ -36,10 +36,10 @@ 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;
+const InferenceServiceSchema = BaseServiceSchema;
 export type InferenceService = z.infer<typeof InferenceServiceSchema>;
 
-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"),
 });
@@ -47,43 +47,81 @@ 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>;
 
-export const GoogleOAuthServiceSchema = BaseServiceSchema.extend({
+const GoogleOAuthServiceSchema = BaseServiceSchema.extend({
   mode: ServiceModeSchema.default("your-own"),
 });
 export type GoogleOAuthService = z.infer<typeof GoogleOAuthServiceSchema>;
 
-export const OutlookOAuthServiceSchema = BaseServiceSchema.extend({
+const OutlookOAuthServiceSchema = BaseServiceSchema.extend({
   mode: ServiceModeSchema.default("your-own"),
 });
 export type OutlookOAuthService = z.infer<typeof OutlookOAuthServiceSchema>;
 
-export const LinearOAuthServiceSchema = BaseServiceSchema.extend({
+const LinearOAuthServiceSchema = BaseServiceSchema.extend({
   mode: ServiceModeSchema.default("your-own"),
 });
 export type LinearOAuthService = z.infer<typeof LinearOAuthServiceSchema>;
 
-export const GitHubOAuthServiceSchema = BaseServiceSchema.extend({
+const GitHubOAuthServiceSchema = BaseServiceSchema.extend({
   mode: ServiceModeSchema.default("your-own"),
 });
 export type GitHubOAuthService = z.infer<typeof GitHubOAuthServiceSchema>;
 
-export const NotionOAuthServiceSchema = BaseServiceSchema.extend({
+const NotionOAuthServiceSchema = BaseServiceSchema.extend({
   mode: ServiceModeSchema.default("your-own"),
 });
 export type NotionOAuthService = z.infer<typeof NotionOAuthServiceSchema>;
 
-export const TwitterOAuthServiceSchema = BaseServiceSchema.extend({
+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
+ * skill process. Kept narrow: only the values the daemon reads before the
+ * meet-host child is spawned live here. Skill-internal configuration
+ * (avatar renderer, consent copy, proactive-chat keywords, etc.) lives in
+ * `skills/meet-join/config-schema.ts` and is sourced from the separate
+ * `<workspace>/config/meet.json` file the skill owns.
+ */
+const MeetHostConfigSchema = z
+  .object({
+    idle_timeout_ms: z
+      .number({
+        error: "services.meet.host.idle_timeout_ms must be a number",
+      })
+      .int()
+      .nonnegative()
+      .optional()
+      .describe(
+        "Idle window in milliseconds after the last active meet session closes before the meet-host child is shut down. Defaults to 5 minutes when unset.",
+      ),
+  })
+  .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
+ * skill-internal `MeetServiceSchema` in `skills/meet-join/config-schema.ts`,
+ * which validates the bot-facing `<workspace>/config/meet.json` file. This
+ * schema only describes the keys the assistant itself reads from its global
+ * `config.json` before the meet-host child process is spawned.
+ */
+const MeetDaemonServiceSchema = z
+  .object({
+    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({})),
   "image-generation": ImageGenerationServiceSchema.default(
@@ -116,6 +154,7 @@ export const ServicesSchema = z.object({
   "twitter-oauth": TwitterOAuthServiceSchema.default(
     TwitterOAuthServiceSchema.parse({}),
   ),
+  meet: MeetDaemonServiceSchema.default(MeetDaemonServiceSchema.parse({})),
 });
 export type Services = z.infer<typeof ServicesSchema>;
 

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({

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.
+ */
+export 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);
+}