@vellumai/assistant 0.10.7 → 0.10.8-dev.202607102228.5945895

package/src/runtime/routes/conversation-query-routes.ts

@@ -41,9 +41,15 @@ import {
   withSuppressedConfigDiskWrites,
   withSuppressedConfigDiskWritesSync,
 } from "../../config/loader.js";
+import { completeCustomProfile } from "../../config/profile-materialization.js";
 import { AssistantConfigSchema } from "../../config/schema.js";
 import { getSchemaAtPath } from "../../config/schema-utils.js";
-import { LLMConfigFragment, ProfileEntry } from "../../config/schemas/llm.js";
+import {
+  DefaultProviderSchema,
+  LLMConfigBase,
+  LLMConfigFragment,
+  ProfileEntry,
+} from "../../config/schemas/llm.js";
 import { VALID_MEMORY_EMBEDDING_PROVIDERS } from "../../config/schemas/memory-storage.js";
 import { ServiceModeSchema } from "../../config/schemas/services.js";
 import { getConfigWatcher } from "../../daemon/config-watcher.js";
@@ -104,6 +110,7 @@ import {
   type LlmContextSummary,
   normalizeLlmContextPayloads,
 } from "./llm-context-normalization.js";
+import { assertLlmRequestLoggingEnabled } from "./llm-request-logs-access.js";
 import type { RouteDefinition, RouteHandlerArgs } from "./types.js";
 
 const validEmbeddingProviderSet = new Set<string>(
@@ -125,9 +132,12 @@ type LlmContextRouteResult = Omit<LlmContextNormalizationResult, "summary"> & {
 };
 
 import {
+  getEffectiveProfile,
+  getEffectiveProfiles,
   INVARIANT_PROFILE_NAMES,
   MANAGED_PROFILE_NAMES,
-} from "../../config/seed-inference-profiles.js";
+} from "../../config/default-profile-catalog.js";
+import { DEFAULT_PROFILE_KEYS } from "../../config/default-profile-names.js";
 import { ACTOR_PRINCIPALS } from "../auth/route-policy.js";
 
 const RESERVED_PROFILE_NAMES = new Set([
@@ -193,11 +203,15 @@ function replaceInferenceProfileConfig(
 ): void {
   const existingLlm = asMutablePlainObject(raw.llm);
   const llm = existingLlm ?? {};
-  if (!existingLlm) raw.llm = llm;
+  if (!existingLlm) {
+    raw.llm = llm;
+  }
 
   const existingProfiles = asMutablePlainObject(llm.profiles);
   const profiles = existingProfiles ?? {};
-  if (!existingProfiles) llm.profiles = profiles;
+  if (!existingProfiles) {
+    llm.profiles = profiles;
+  }
 
   const existingProfile = asMutablePlainObject(profiles[name]) ?? {};
   const nextProfile: Record<string, unknown> = { ...existingProfile };
@@ -272,8 +286,12 @@ function applyStoredProviderToLlmContextResult(
 type LlmContextView = "full" | "summary";
 
 function resolveLlmContextView(view: string | undefined): LlmContextView {
-  if (view === undefined || view === "full") return "full";
-  if (view === "summary") return "summary";
+  if (view === undefined || view === "full") {
+    return "full";
+  }
+  if (view === "summary") {
+    return "summary";
+  }
   throw new BadRequestError(
     `Invalid view parameter: ${view}. Expected "full" or "summary".`,
   );
@@ -285,7 +303,9 @@ function resolveLlmContextView(view: string | undefined): LlmContextView {
  * for malformed/legacy rows — a bad blob must never break the inspector.
  */
 function parseLatencyBreakdown(raw: string | null): LatencyBreakdown | null {
-  if (!raw) return null;
+  if (!raw) {
+    return null;
+  }
   try {
     const parsed = LatencyBreakdownSchema.safeParse(JSON.parse(raw));
     return parsed.success ? parsed.data : null;
@@ -494,7 +514,9 @@ function synthesizeLegacyInferenceModeForPlatform(
   root: Record<string, unknown>,
 ): void {
   const services = readPlainObject(root.services);
-  if (!services) return;
+  if (!services) {
+    return;
+  }
   let inference = readPlainObject(services.inference);
   if (!inference) {
     inference = {};
@@ -521,9 +543,13 @@ function stripTransportHeadersRecursively(value: unknown): void {
   }
 
   const object = readPlainObject(value);
-  if (!object) return;
+  if (!object) {
+    return;
+  }
   const transport = readPlainObject(object.transport);
-  if (transport) delete transport.headers;
+  if (transport) {
+    delete transport.headers;
+  }
   for (const child of Object.values(object)) {
     stripTransportHeadersRecursively(child);
   }
@@ -535,9 +561,13 @@ function containsTransportHeadersRecursively(value: unknown): boolean {
   }
 
   const object = readPlainObject(value);
-  if (!object) return false;
+  if (!object) {
+    return false;
+  }
   const transport = readPlainObject(object.transport);
-  if (transport && Object.hasOwn(transport, "headers")) return true;
+  if (transport && Object.hasOwn(transport, "headers")) {
+    return true;
+  }
   return Object.values(object).some((child) =>
     containsTransportHeadersRecursively(child),
   );
@@ -545,15 +575,21 @@ function containsTransportHeadersRecursively(value: unknown): boolean {
 
 function sanitizeMcpTransportHeadersForSettingsRead(config: unknown): void {
   const root = readPlainObject(config);
-  if (!root) return;
+  if (!root) {
+    return;
+  }
   const mcp = readPlainObject(root.mcp);
-  if (!mcp || !Object.hasOwn(mcp, "servers")) return;
+  if (!mcp || !Object.hasOwn(mcp, "servers")) {
+    return;
+  }
   if (Array.isArray(mcp.servers)) {
     stripTransportHeadersRecursively(mcp.servers);
     return;
   }
   const servers = readPlainObject(mcp.servers);
-  if (!servers) return;
+  if (!servers) {
+    return;
+  }
   for (const server of Object.values(servers)) {
     stripTransportHeadersRecursively(server);
   }
@@ -562,19 +598,25 @@ function sanitizeMcpTransportHeadersForSettingsRead(config: unknown): void {
 function patchContainsMcpTransportHeaders(patch: unknown): boolean {
   const root = readPlainObject(patch);
   const mcp = readPlainObject(root?.mcp);
-  if (!mcp || !Object.hasOwn(mcp, "servers")) return false;
+  if (!mcp || !Object.hasOwn(mcp, "servers")) {
+    return false;
+  }
   if (Array.isArray(mcp.servers)) {
     return containsTransportHeadersRecursively(mcp.servers);
   }
   const servers = readPlainObject(mcp.servers);
-  if (!servers) return false;
+  if (!servers) {
+    return false;
+  }
   return Object.values(servers).some((server) =>
     containsTransportHeadersRecursively(server),
   );
 }
 
 function rejectMcpTransportHeaderWrite(patch: unknown): void {
-  if (!patchContainsMcpTransportHeaders(patch)) return;
+  if (!patchContainsMcpTransportHeaders(patch)) {
+    return;
+  }
   throw new BadRequestError(
     "MCP authentication headers must be managed through MCP server add/update APIs, not generic config writes.",
   );
@@ -617,6 +659,7 @@ const ConfigGetResponseSchema = z
         default: LLMConfigFragment.extend({
           provider_connection: z.string().optional(),
         }).optional(),
+        defaultProvider: DefaultProviderSchema.optional(),
         profiles: z.record(z.string(), WireProfileEntry).optional(),
         profileOrder: z.array(z.string()).optional(),
         activeProfile: z.string().optional(),
@@ -784,6 +827,7 @@ function handleGetConfig() {
   try {
     const config = applyContextDefaultsToRawConfig(loadRawConfig());
     sanitizeMcpTransportHeadersForSettingsRead(config);
+    overlayEffectiveProfilesForWire(config);
     enrichProfilesForWire(config);
     return config;
   } catch (err) {
@@ -792,6 +836,31 @@ function handleGetConfig() {
   }
 }
 
+/**
+ * Replace `llm.profiles` in an outgoing config response with the effective
+ * profile view (code-catalog default bodies + workspace overlays). Default
+ * profile CONTENT is code-owned and the workspace holds at most a thin stub,
+ * but clients (settings UI, sticky-profile pickers) need the full bodies to
+ * render labels/models — so the wire view materializes them. Wire-only:
+ * `normalizeManagedProfileWrites` reduces echoed bodies back to the
+ * workspace-owned fields on the write paths, so a `config get` →
+ * `config set` round-trip never persists catalog content.
+ */
+function overlayEffectiveProfilesForWire(config: unknown): void {
+  const root = readPlainObject(config);
+  if (!root) {
+    return;
+  }
+  const existingLlm = readPlainObject(root.llm);
+  const llm = existingLlm ?? {};
+  if (!existingLlm) {
+    root.llm = llm;
+  }
+  llm.profiles = getEffectiveProfiles(
+    readPlainObject(llm.profiles) as Record<string, ProfileEntry> | undefined,
+  );
+}
+
 /**
  * Per-profile keys that exist only on the wire — stamped onto config
  * responses by {@link enrichProfilesForWire}, never persisted to disk.
@@ -823,6 +892,122 @@ function stripWireOnlyProfileKeys(patch: unknown): void {
   }
 }
 
+/**
+ * Normalize managed default-profile entries in a config-write fragment, in
+ * place, so a `config get` → write round-trip of the enriched wire view is a
+ * no-op while genuine edit attempts still reach the invariant guard's
+ * precise rejections:
+ *
+ * - A default name backed by a user-source on-disk entry is a legacy shadow
+ *   and stays fully editable — left untouched here.
+ * - Echo-stripping: any field whose incoming value equals the current
+ *   effective (wire) value is deleted from the fragment — it is catalog
+ *   content the client read from us, not user input. Values that DIFFER stay
+ *   in the fragment for {@link assertInvariantProfilesPreserved} to reject
+ *   (or, for `status`, to judge as the one legal transition).
+ * - A default name with NO on-disk entry is catalog-owned: after
+ *   echo-stripping, any remaining content field, a `disabled` status, or a
+ *   non-managed `source` is rejected — default names cannot be newly
+ *   shadowed or given content. A clean echo reduces to a no-op
+ *   `{source: "managed"}` stub.
+ *
+ * Entries are mutated (never replaced) so the normalization also reaches
+ * `handleSetConfig`'s `raw` write, which shares object references with the
+ * inspected patch shape.
+ */
+export function normalizeManagedProfileWrites(patch: unknown): void {
+  const root = readPlainObject(patch);
+  const llm = readPlainObject(root?.llm);
+  const profiles = readPlainObject(llm?.profiles);
+  if (!profiles) {
+    return;
+  }
+
+  const currentProfiles = readPlainObject(
+    readPlainObject(loadRawConfig().llm)?.profiles,
+  ) as Record<string, ProfileEntry> | undefined;
+
+  for (const name of Object.keys(profiles)) {
+    if (!MANAGED_PROFILE_NAMES.has(name)) {
+      continue;
+    }
+    const entry = readPlainObject(profiles[name]);
+    if (!entry) {
+      continue;
+    }
+
+    const current = readPlainObject(currentProfiles?.[name]);
+    if (current && current.source !== "managed") {
+      // Legacy user-owned shadow: fully editable, normal custom-profile rules.
+      continue;
+    }
+
+    const effective = readPlainObject(
+      getEffectiveProfile(currentProfiles, name),
+    );
+    for (const key of Object.keys(entry)) {
+      if (key === "source" || key === "status") {
+        continue;
+      }
+      const matchesEffective =
+        effective != null &&
+        key in effective &&
+        isDeepStrictEqual(entry[key], effective[key]);
+      if (current == null || !(key in current)) {
+        // Not on disk: a value matching the wire view is a client echo of
+        // catalog content — drop it. Anything else stays for the guard.
+        if (matchesEffective) {
+          delete entry[key];
+        }
+        continue;
+      }
+      // The key exists on disk (a frozen overlay field, or stale content an
+      // overlay persisted). Deleting it would read as a key removal on a
+      // full-entry SET, so instead: an echo of the wire value that differs
+      // from disk is pinned back to the on-disk value (no change for the
+      // guard to reject); everything else is left for the guard's
+      // frozen-field comparison.
+      if (matchesEffective && !isDeepStrictEqual(entry[key], current[key])) {
+        entry[key] = current[key];
+      }
+    }
+
+    if (current) {
+      // Existing stub: the guard compares the merged result against it and
+      // rejects everything but the status re-enable.
+      if (entry.source === undefined) {
+        entry.source = "managed";
+      }
+      continue;
+    }
+
+    // No on-disk entry: the name is catalog-owned. Nothing but a clean echo
+    // (which reduced to source/status above) may pass.
+    if ("source" in entry && entry.source !== "managed") {
+      throw new BadRequestError(
+        `Cannot create profile "${name}" — the name is reserved for a code-defined default profile.`,
+      );
+    }
+    if (
+      "status" in entry &&
+      entry.status != null &&
+      entry.status !== "active"
+    ) {
+      throw new BadRequestError(`Cannot disable managed profile "${name}".`);
+    }
+    const residual = Object.keys(entry).filter(
+      (key) => key !== "source" && key !== "status",
+    );
+    if (residual.length > 0) {
+      throw new BadRequestError(
+        `Cannot edit managed profile "${name}" fields [${residual.join(", ")}]. ` +
+          `Managed profiles are read-only; duplicate to a custom profile to customize.`,
+      );
+    }
+    entry.source = "managed";
+  }
+}
+
 /**
  * Annotate each profile in `config.llm.profiles` with wire-only flags
  * (`WIRE_ONLY_PROFILE_KEYS`) — never persisted to disk:
@@ -838,21 +1023,31 @@ function stripWireOnlyProfileKeys(patch: unknown): void {
  */
 function enrichProfilesForWire(config: unknown): void {
   const root = readPlainObject(config);
-  if (!root) return;
+  if (!root) {
+    return;
+  }
   const llm = readPlainObject(root.llm);
-  if (!llm) return;
+  if (!llm) {
+    return;
+  }
   const profiles = readPlainObject(llm.profiles);
-  if (!profiles) return;
+  if (!profiles) {
+    return;
+  }
 
   for (const [name, profile] of Object.entries(profiles)) {
     const entry = readPlainObject(profile);
-    if (!entry) continue;
+    if (!entry) {
+      continue;
+    }
     if (INVARIANT_PROFILE_NAMES.has(name) && entry.source === "managed") {
       entry.invariant = true;
     }
     const provider = entry.provider;
     const model = entry.model;
-    if (typeof provider !== "string" || typeof model !== "string") continue;
+    if (typeof provider !== "string" || typeof model !== "string") {
+      continue;
+    }
 
     const catalogProvider = PROVIDER_CATALOG.find((p) => p.id === provider);
     const catalogModel = catalogProvider?.models.find((m) => m.id === model);
@@ -892,19 +1087,27 @@ function handleGetConfigSchema({ queryParams = {} }: RouteHandlerArgs) {
   };
 }
 
-function rejectManagedProfileDeletion(body: Record<string, unknown>): void {
+export function rejectManagedProfileDeletion(
+  body: Record<string, unknown>,
+): void {
   const llm = asMutablePlainObject(body.llm);
-  if (!llm) return;
+  if (!llm) {
+    return;
+  }
   if ("profiles" in llm && llm.profiles === null) {
     throw new BadRequestError(
       "Cannot null llm.profiles — managed profiles would be deleted.",
     );
   }
   const profiles = asMutablePlainObject(llm.profiles);
-  if (!profiles) return;
+  if (!profiles) {
+    return;
+  }
   const existingProfiles = asMutablePlainObject(getConfig().llm.profiles) ?? {};
   for (const name of Object.keys(profiles)) {
-    if (profiles[name] !== null || !MANAGED_PROFILE_NAMES.has(name)) continue;
+    if (profiles[name] !== null || !MANAGED_PROFILE_NAMES.has(name)) {
+      continue;
+    }
     // Only block deletion when the on-disk entry is Vellum-managed. A
     // user-owned profile sharing a managed name carries a non-managed `source`
     // and is freely deletable.
@@ -918,11 +1121,11 @@ function rejectManagedProfileDeletion(body: Record<string, unknown>): void {
 /**
  * Enforce the managed-profile invariants at the config-write choke point.
  *
- * Protects the *seeded* managed profiles (`INVARIANT_PROFILE_NAMES`) that
- * live in workspace config. The guard only has an effect while managed
- * profiles are seeded there: it checks entries present in the OLD config, so
- * if they stop being stored in workspace config it has nothing to protect
- * and can be deleted along with the seeding.
+ * Protects the thin managed stubs (`INVARIANT_PROFILE_NAMES`) that live in
+ * workspace config. Default profile CONTENT is code-owned and only exists on
+ * the wire, so the guard's job is the stub itself: it checks entries present
+ * in the OLD config, and `normalizeManagedProfileWrites` reduces incoming
+ * managed entries to the workspace-owned fields before this comparison runs.
  *
  * Invariance is gated on managed ownership: a name is enforced only when the
  * OLD entry's `source` is `"managed"`. A user-owned profile sharing a
@@ -1012,6 +1215,83 @@ function assertInvariantProfilesPreserved(
   }
 }
 
+/**
+ * `{...raw, ...completed}` recursively: completed (schema-known) values win,
+ * raw keys the schema stripped survive at every depth.
+ */
+function mergePreservingUnknownKeys(
+  raw: Record<string, unknown>,
+  completed: Record<string, unknown>,
+): Record<string, unknown> {
+  const out: Record<string, unknown> = { ...raw, ...completed };
+  for (const [key, value] of Object.entries(completed)) {
+    const rawValue = raw[key];
+    if (
+      readPlainObject(value) !== undefined &&
+      readPlainObject(rawValue) !== undefined
+    ) {
+      out[key] = mergePreservingUnknownKeys(
+        rawValue as Record<string, unknown>,
+        value as Record<string, unknown>,
+      );
+    }
+  }
+  return out;
+}
+
+/**
+ * Custom profiles persist as complete overrides: any user-source, non-mix
+ * profile entry this write creates or changes is completed against
+ * `llm.default` (`completeCustomProfile`) before it lands on disk, so no
+ * write path can persist a new partial profile. Entries the write did not
+ * touch are left byte-identical — an unrelated config write must not rewrite
+ * profile entries. Entries that do not parse as a `ProfileEntry` are also
+ * left untouched; full-config parsing owns their rejection/recovery.
+ */
+function completeChangedCustomProfiles(
+  preWrite: Record<string, unknown>,
+  raw: Record<string, unknown>,
+): void {
+  const profiles = asMutablePlainObject(readPlainObject(raw.llm)?.profiles);
+  if (!profiles) {
+    return;
+  }
+  const parsedDefault = LLMConfigBase.safeParse(
+    readPlainObject(raw.llm)?.default ?? {},
+  );
+  if (!parsedDefault.success) {
+    return;
+  }
+  const prior = readPlainObject(readPlainObject(preWrite.llm)?.profiles) ?? {};
+  for (const [name, entry] of Object.entries(profiles)) {
+    if (isDeepStrictEqual(entry, prior[name])) {
+      continue;
+    }
+    const parsedEntry = ProfileEntry.safeParse(entry);
+    if (!parsedEntry.success) {
+      continue;
+    }
+    // `source: "managed"` is only meaningful on catalog-owned names. On any
+    // other name it would skip completion (and read as a locked entry), so a
+    // body claiming it is normalized to user-owned before completing.
+    const entryData =
+      parsedEntry.data.source === "managed" && !MANAGED_PROFILE_NAMES.has(name)
+        ? { ...parsedEntry.data, source: "user" as const }
+        : parsedEntry.data;
+    // Merge the completed known fields over the original raw entry at every
+    // depth: `safeParse` strips keys the schema doesn't know (top-level and
+    // inside nested objects like `contextWindow`), and dropping them here
+    // would delete forward-compatible fields whenever the entry is edited.
+    profiles[name] = mergePreservingUnknownKeys(
+      readPlainObject(entry) ?? {},
+      completeCustomProfile(parsedDefault.data, entryData) as Record<
+        string,
+        unknown
+      >,
+    );
+  }
+}
+
 /**
  * Persist a mutated raw config object to disk and synchronize the running
  * daemon (file-watcher, embedding cache, provider registry).
@@ -1019,7 +1299,7 @@ function assertInvariantProfilesPreserved(
  * Shared by `handlePatchConfig` and `handleSetConfig` so both write paths get
  * identical post-write side effects.
  */
-async function commitConfigWrite(
+export async function commitConfigWrite(
   raw: Record<string, unknown>,
   opLabel: string,
 ): Promise<void> {
@@ -1027,7 +1307,9 @@ async function commitConfigWrite(
   // so it is the pre-write state; raw-to-raw comparison avoids parsed-vs-raw
   // false diffs. Runs before the watcher-suppress/save sequence so a
   // rejection needs no suppress-flag or cache cleanup.
-  assertInvariantProfilesPreserved(loadRawConfig(), raw);
+  const preWrite = loadRawConfig();
+  completeChangedCustomProfiles(preWrite, raw);
+  assertInvariantProfilesPreserved(preWrite, raw);
 
   // Suppress the file-watcher callback for the duration of the debounce
   // window. Without this, the ConfigWatcher detects the config.json write
@@ -1080,6 +1362,7 @@ async function handlePatchConfig({ body }: RouteHandlerArgs) {
     throw new BadRequestError("Body must be a non-empty JSON object");
   }
   stripWireOnlyProfileKeys(body);
+  normalizeManagedProfileWrites(body);
   rejectManagedProfileDeletion(body as Record<string, unknown>);
   rejectMcpTransportHeaderWrite(body);
 
@@ -1091,6 +1374,7 @@ async function handlePatchConfig({ body }: RouteHandlerArgs) {
 
   const merged = applyContextDefaultsToRawConfig(loadRawConfig());
   sanitizeMcpTransportHeadersForSettingsRead(merged);
+  overlayEffectiveProfilesForWire(merged);
   enrichProfilesForWire(merged);
   return merged;
 }
@@ -1149,11 +1433,41 @@ async function handleSetConfig({ body }: RouteHandlerArgs) {
   const patchShape: Record<string, unknown> = {};
   setNestedValue(patchShape, path, value);
   stripWireOnlyProfileKeys(patchShape);
+  normalizeManagedProfileWrites(patchShape);
   rejectManagedProfileDeletion(patchShape);
   rejectMcpTransportHeaderWrite(patchShape);
 
   const raw = loadRawConfig();
+  // A SET below the entry level (`llm.profiles.<name>.<leaf>`) writes the
+  // primitive leaf directly into `raw`, bypassing the by-reference
+  // normalization above — creating an entry for a managed-owned name would
+  // leave it source-less, and a source-less entry reads as a user shadow
+  // that blocks the catalog body. Stamp the managed marker onto the written
+  // entry when the name was absent or managed-owned before this write.
+  const managedEntryName =
+    pathSegments[0] === "llm" &&
+    pathSegments[1] === "profiles" &&
+    pathSegments.length >= 3 &&
+    MANAGED_PROFILE_NAMES.has(pathSegments[2]!)
+      ? pathSegments[2]!
+      : undefined;
+  const priorManagedEntry = managedEntryName
+    ? readPlainObject(
+        readPlainObject(readPlainObject(raw.llm)?.profiles)?.[managedEntryName],
+      )
+    : undefined;
   setNestedValue(raw, path, value);
+  if (
+    managedEntryName &&
+    (priorManagedEntry == null || priorManagedEntry.source === "managed")
+  ) {
+    const written = readPlainObject(
+      readPlainObject(readPlainObject(raw.llm)?.profiles)?.[managedEntryName],
+    );
+    if (written && written.source === undefined) {
+      written.source = "managed";
+    }
+  }
 
   await commitConfigWrite(raw, "set");
   return { ok: true };
@@ -1170,7 +1484,9 @@ async function handleSetConfig({ body }: RouteHandlerArgs) {
 function handleValidateAllowlist() {
   try {
     const errors = validateAllowlistFile();
-    if (errors == null) return { exists: false } as const;
+    if (errors == null) {
+      return { exists: false } as const;
+    }
     return { exists: true, errors } as const;
   } catch (err) {
     // `validateAllowlistFile` does a raw `JSON.parse` on
@@ -1213,11 +1529,16 @@ async function handleReplaceInferenceProfile({
   const isManaged =
     MANAGED_PROFILE_NAMES.has(name) &&
     (existingProfile == null || existingProfile.source === "managed");
-  // A managed profile name with no materialized entry (e.g. a flag-gated profile
-  // whose flag is off) cannot be patched: writing label/status here would persist
-  // a source-less stub that later blocks the real managed profile from being
-  // seeded. Reject rather than create a placeholder.
-  if (MANAGED_PROFILE_NAMES.has(name) && existingProfile == null) {
+  // A flag-gated managed name (`os-beta`) with no materialized entry cannot
+  // be patched: it only resolves while the flag reconcile has created its
+  // stub, so writing status here would persist an entry that fights the
+  // reconcile. The always-available defaults are catalog-owned even when
+  // absent — a status re-enable on them just creates the thin stub.
+  if (
+    MANAGED_PROFILE_NAMES.has(name) &&
+    existingProfile == null &&
+    !(DEFAULT_PROFILE_KEYS as readonly string[]).includes(name)
+  ) {
     throw new BadRequestError(
       `Profile "${name}" is not currently available and cannot be edited.`,
     );
@@ -1268,7 +1589,9 @@ async function handleReplaceInferenceProfile({
         `Mix profile "${name}" cannot also set [${extraneous.join(", ")}] — a mix only references other profiles plus metadata (label, description, status).`,
       );
     }
-    const existingProfiles = getConfig().llm.profiles ?? {};
+    // Validate arms against the effective view (matches the resolver and
+    // `LLMSchema.superRefine`), not the raw workspace record.
+    const existingProfiles = getEffectiveProfiles(getConfig().llm.profiles);
     parsed.data.mix.forEach((arm, index) => {
       if (arm.profile === name) {
         throw new BadRequestError(
@@ -1384,6 +1707,10 @@ function applyManagedProfileReenable(
   const nextProfile: Record<string, unknown> = {
     ...(asMutablePlainObject(profiles[name]) ?? {}),
   };
+  // Only reached for managed-owned names (the route's managed gate), so a
+  // freshly created stub must carry the managed marker the effective view
+  // and write guards key on.
+  nextProfile.source = "managed";
   if (status === null) {
     delete nextProfile.status;
   } else {
@@ -1439,8 +1766,12 @@ function resolveConversationKind(
   if (source === MEMORY_V2_CONSOLIDATION_SOURCE) {
     return "background_memory_consolidation";
   }
-  if (conversationType === "background") return "background";
-  if (conversationType === "scheduled") return "scheduled";
+  if (conversationType === "background") {
+    return "background";
+  }
+  if (conversationType === "scheduled") {
+    return "scheduled";
+  }
   return "user";
 }
 
@@ -1448,6 +1779,7 @@ async function handleGetLlmContext({
   pathParams = {},
   queryParams = {},
 }: RouteHandlerArgs) {
+  assertLlmRequestLoggingEnabled();
   const messageId = pathParams.id;
   if (!messageId) {
     throw new BadRequestError("message id is required");
@@ -1491,6 +1823,7 @@ async function handleGetLlmContext({
 async function handleGetConversationLlmContext({
   queryParams = {},
 }: RouteHandlerArgs) {
+  assertLlmRequestLoggingEnabled();
   const conversationKey = queryParams.conversationKey;
   const requestedConversationId = queryParams.conversationId;
   const view = resolveLlmContextView(queryParams.view);
@@ -1560,6 +1893,7 @@ async function handleGetConversationLlmContext({
 async function handleGetLlmRequestLogPayload({
   pathParams = {},
 }: RouteHandlerArgs) {
+  assertLlmRequestLoggingEnabled();
   const logId = pathParams.id;
   if (!logId) {
     throw new BadRequestError("log id is required");
@@ -1587,6 +1921,7 @@ async function handleGetLlmRequestLogPayload({
 async function handleGetLlmRequestLogContext({
   pathParams = {},
 }: RouteHandlerArgs) {
+  assertLlmRequestLoggingEnabled();
   const logId = pathParams.id;
   if (!logId) {
     throw new BadRequestError("log id is required");