@vellumai/assistant 0.9.1-staging.1 → 0.10.0-staging.2

package/src/runtime/routes/__tests__/conversation-management-routes.test.ts

@@ -26,6 +26,8 @@ mock.module("../../assistant-event-hub.js", () => ({
   broadcastMessage: () => {},
 }));
 
+import { eq } from "drizzle-orm";
+
 import { getDb } from "../../../memory/db-connection.js";
 import { initializeDb } from "../../../memory/db-init.js";
 import { conversations } from "../../../memory/schema.js";
@@ -71,6 +73,10 @@ function findHandler(routes: RouteDefinition[], operationId: string) {
   return route.handler;
 }
 
+const createHandler = findHandler(
+  CONVERSATION_MANAGEMENT_ROUTES,
+  "createConversation",
+);
 const putHandler = findHandler(
   CONVERSATION_MANAGEMENT_ROUTES,
   "setConversationInferenceProfile",
@@ -112,6 +118,67 @@ function seedConversation(id: string): void {
 // Tests
 // ---------------------------------------------------------------------------
 
+describe("POST /v1/conversations (createConversation)", () => {
+  beforeEach(() => {
+    clearConversations();
+  });
+
+  function readConversation(id: string) {
+    return getDb()
+      .select({
+        title: conversations.title,
+        isAutoTitle: conversations.isAutoTitle,
+      })
+      .from(conversations)
+      .where(eq(conversations.id, id))
+      .get();
+  }
+
+  test("with a title → persists it as a user-set title (isAutoTitle = 0)", async () => {
+    const result = (await createHandler({
+      body: { conversationType: "standard", title: "Setting up your check-in" },
+    })) as { id: string; created: boolean };
+
+    expect(result.created).toBe(true);
+    const row = readConversation(result.id);
+    expect(row?.title).toBe("Setting up your check-in");
+    // isAutoTitle = 0 keeps the async LLM titler from overwriting it.
+    expect(row?.isAutoTitle).toBe(0);
+  });
+
+  test("blank title falls back to the replaceable 'New Conversation' placeholder", async () => {
+    const result = (await createHandler({
+      body: { conversationType: "standard", title: "   " },
+    })) as { id: string; created: boolean };
+
+    expect(result.created).toBe(true);
+    const row = readConversation(result.id);
+    expect(row?.title).toBe("New Conversation");
+    // Default auto-title flag (1) leaves it replaceable by the auto-titler.
+    expect(row?.isAutoTitle).toBe(1);
+  });
+
+  test("no title → 'New Conversation' placeholder", async () => {
+    const result = (await createHandler({
+      body: { conversationType: "standard" },
+    })) as { id: string; created: boolean };
+
+    expect(result.created).toBe(true);
+    const row = readConversation(result.id);
+    expect(row?.title).toBe("New Conversation");
+    expect(row?.isAutoTitle).toBe(1);
+  });
+
+  test("non-string title → BadRequestError (not a 500), no row created", () => {
+    // The shared route adapter doesn't runtime-validate the body, so the
+    // handler must reject a malformed title before `.trim()` throws.
+    expect(() =>
+      createHandler({ body: { conversationType: "standard", title: 123 } }),
+    ).toThrow(/title must be a string/);
+    expect(getDb().select().from(conversations).all()).toHaveLength(0);
+  });
+});
+
 describe("PUT /v1/conversations/:id/inference-profile", () => {
   beforeEach(() => {
     clearConversations();

package/src/runtime/routes/__tests__/plugins-routes.test.ts

@@ -75,7 +75,6 @@ import {
   PluginMergeBaselineError,
   PluginNotUpgradableError,
   type PluginUpgradeResult,
-  PluginUpgradeStrategyUnsupportedError,
   type UpgradePluginDeps,
   type UpgradePluginOptions,
 } from "../../../cli/lib/upgrade-plugin.js";
@@ -183,7 +182,6 @@ const upgradeSpy = mock(
 mock.module("../../../cli/lib/upgrade-plugin.js", () => ({
   PluginMergeBaselineError,
   PluginNotUpgradableError,
-  PluginUpgradeStrategyUnsupportedError,
   upgradePlugin: upgradeSpy,
 }));
 
@@ -1004,6 +1002,10 @@ function inspection(
           }
         : overrides.remote,
     remoteError: overrides.remoteError ?? null,
+    surfaces:
+      overrides.surfaces === undefined
+        ? { skills: [], hooks: ["post-model-call"], tools: [] }
+        : overrides.surfaces,
   };
 }
 
@@ -1109,6 +1111,8 @@ function upgradeResult(
     fileCount: overrides.fileCount === undefined ? 12 : overrides.fileCount,
     dryRun: overrides.dryRun ?? false,
     strategy: overrides.strategy ?? "overwrite",
+    conflicts: overrides.conflicts ?? [],
+    binaryConflicts: overrides.binaryConflicts ?? [],
     provenanceWasUnknown: overrides.provenanceWasUnknown ?? false,
   };
 }
@@ -1124,6 +1128,8 @@ async function invokeUpgrade(args: RouteHandlerArgs = {}): Promise<{
   fileCount: number | null;
   dryRun: boolean;
   strategy: string;
+  conflicts: readonly string[];
+  binaryConflicts: readonly string[];
   provenanceWasUnknown: boolean;
 }> {
   return (await upgradeHandler(args)) as {
@@ -1137,6 +1143,8 @@ async function invokeUpgrade(args: RouteHandlerArgs = {}): Promise<{
     fileCount: number | null;
     dryRun: boolean;
     strategy: string;
+    conflicts: readonly string[];
+    binaryConflicts: readonly string[];
     provenanceWasUnknown: boolean;
   };
 }
@@ -1168,6 +1176,8 @@ describe("POST /v1/plugins/:name/upgrade", () => {
       fileCount: 12,
       dryRun: false,
       strategy: "overwrite",
+      conflicts: [],
+      binaryConflicts: [],
       provenanceWasUnknown: false,
     });
     // AND the name + dryRun are forwarded to the lib (strategy omitted)
@@ -1199,19 +1209,31 @@ describe("POST /v1/plugins/:name/upgrade", () => {
     });
   });
 
-  test("PluginUpgradeStrategyUnsupportedError \u2192 BadRequestError (400)", async () => {
-    // The `assistant` strategy is recognized but not yet implemented: a
-    // well-formed request the server cannot honor.
-    upgradeSpy.mockImplementation(async () => {
-      throw new PluginUpgradeStrategyUnsupportedError("assistant");
+  test("projects conflicts + binaryConflicts from the assistant strategy onto the wire", async () => {
+    // GIVEN upgradePlugin merges with conflict markers under `assistant`
+    upgradeSpy.mockImplementation(async () =>
+      upgradeResult({
+        strategy: "assistant",
+        conflicts: ["hooks/post-model-call.ts"],
+        binaryConflicts: ["assets/icon.png"],
+      }),
+    );
+
+    // WHEN the handler runs with the `assistant` strategy
+    const result = await invokeUpgrade({
+      pathParams: { name: "level-up" },
+      body: { strategy: "assistant" },
     });
 
-    await expect(
-      invokeUpgrade({
-        pathParams: { name: "level-up" },
-        body: { strategy: "assistant" },
-      }),
-    ).rejects.toBeInstanceOf(BadRequestError);
+    // THEN the conflicted paths are surfaced for the assistant to resolve
+    expect(result.strategy).toBe("assistant");
+    expect(result.conflicts).toEqual(["hooks/post-model-call.ts"]);
+    expect(result.binaryConflicts).toEqual(["assets/icon.png"]);
+    expect(upgradeSpy.mock.calls[0]?.[0]).toEqual({
+      name: "level-up",
+      dryRun: undefined,
+      strategy: "assistant",
+    });
   });
 
   test("PluginMergeBaselineError \u2192 ConflictError (409)", async () => {

package/src/runtime/routes/browser-tabs-routes.ts

@@ -8,6 +8,7 @@
 import { z } from "zod";
 
 import { findConversation } from "../../daemon/conversation-registry.js";
+import { HostBrowserProxy } from "../../daemon/host-browser-proxy.js";
 import { getCdpClient } from "../../tools/browser/cdp-client/factory.js";
 import {
   clearPinnedTab,
@@ -51,6 +52,14 @@ async function handleBrowserTabs({ body = {} }: RouteHandlerArgs) {
 
   const cdpOptions = { mode: "extension" as const, targetClientId };
 
+  // Every tabs command pins extension mode. Absorb a brief extension SSE
+  // reconnect blip so a flapping connection doesn't surface as a hard
+  // "no Chrome Extension connected" error.
+  await HostBrowserProxy.instance.waitForExtensionClient(
+    context.sourceActorPrincipalId,
+    targetClientId,
+  );
+
   if (command === "list") {
     const cdp = getCdpClient(context, cdpOptions);
     try {

package/src/runtime/routes/canonical-guardian-expiry-sweep.ts

@@ -18,6 +18,7 @@
  * clients polling prompts) observe the expired status directly.
  */
 
+import { withdrawGuardianRequestCards } from "../../approvals/guardian-card-withdrawal.js";
 import {
   listCanonicalGuardianRequests,
   resolveCanonicalGuardianRequest,
@@ -42,7 +43,7 @@ let sweepInProgress = false;
  * concurrent decision that wins the race is never overwritten by the
  * sweep.  Returns the count of requests transitioned to expired.
  */
-function sweepExpiredCanonicalGuardianRequests(): number {
+async function sweepExpiredCanonicalGuardianRequests(): Promise<number> {
   const pending = listCanonicalGuardianRequests({ status: "pending" });
   const now = Date.now();
   let expiredCount = 0;
@@ -71,6 +72,14 @@ function sweepExpiredCanonicalGuardianRequests(): number {
         },
         "Expired canonical guardian request via sweep",
       );
+
+      // Withdraw the now-stale approval cards on every surface. No origin
+      // channel — the expiry is system-driven, so all surfaces (including
+      // in-app) are withdrawn. Best-effort and non-throwing.
+      await withdrawGuardianRequestCards({
+        request: resolved,
+        status: "expired",
+      });
     }
   }
 
@@ -93,13 +102,13 @@ export function startCanonicalGuardianExpirySweep(): void {
   sweepTimer = setInterval(() => {
     if (sweepInProgress) return;
     sweepInProgress = true;
-    try {
-      sweepExpiredCanonicalGuardianRequests();
-    } catch (err) {
-      log.error({ err }, "Canonical guardian expiry sweep failed");
-    } finally {
-      sweepInProgress = false;
-    }
+    void sweepExpiredCanonicalGuardianRequests()
+      .catch((err) => {
+        log.error({ err }, "Canonical guardian expiry sweep failed");
+      })
+      .finally(() => {
+        sweepInProgress = false;
+      });
   }, SWEEP_INTERVAL_MS);
 }
 

package/src/runtime/routes/client-routes.ts

@@ -12,6 +12,10 @@ import { isHttpAuthDisabled } from "../../config/env.js";
 import { datesToISO } from "../../util/json.js";
 import { assistantEventHub } from "../assistant-event-hub.js";
 import { ACTOR_PRINCIPALS } from "../auth/route-policy.js";
+import {
+  DEFAULT_HEARTBEAT_INTERVAL_MS,
+  isClientDegraded,
+} from "../client-health.js";
 import { NotFoundError } from "./errors.js";
 import type { RouteDefinition } from "./types.js";
 
@@ -65,6 +69,7 @@ export const ROUTES: RouteDefinition[] = [
               c.actorPrincipalId === callerPrincipalId,
           );
 
+      const now = new Date();
       return {
         clients: filtered.map((c) =>
           datesToISO({
@@ -74,6 +79,11 @@ export const ROUTES: RouteDefinition[] = [
             machineName: c.machineName,
             connectedAt: c.connectedAt,
             lastActiveAt: c.lastActiveAt,
+            degraded: isClientDegraded(
+              c.lastActiveAt,
+              now,
+              DEFAULT_HEARTBEAT_INTERVAL_MS,
+            ),
           }),
         ),
       };

package/src/runtime/routes/contact-routes.ts

@@ -50,6 +50,30 @@ function withGuardianNameOverride<
   return contact;
 }
 
+/** Adds `externalUserId` (= `address`) to each channel for older macOS clients. */
+function withChannelCompat<T extends { channels: { address: string }[] }>(
+  contact: T,
+): T {
+  return {
+    ...contact,
+    channels: contact.channels.map((ch) => ({
+      ...ch,
+      externalUserId: ch.address,
+    })),
+  };
+}
+
+/** Compose both response transforms (guardian display name + channel compat). */
+function prepareContactResponse<
+  T extends {
+    role: string;
+    displayName: string;
+    channels: { address: string }[];
+  },
+>(contact: T): T {
+  return withChannelCompat(withGuardianNameOverride(contact));
+}
+
 const VALID_CONTACT_TYPES: readonly ContactType[] = ["human", "assistant"];
 
 const VALID_CHANNEL_STATUSES: readonly ChannelStatus[] = [
@@ -87,6 +111,7 @@ const contactChannelSchema = z.object({
   type: z.string(),
   address: z.string(),
   isPrimary: z.boolean(),
+  /** @deprecated Echoes `address` for backwards compatibility with older macOS clients. */
   externalUserId: z.string().nullable(),
   status: z.string(),
   policy: z.string(),
@@ -143,14 +168,14 @@ function handleListContacts(queryParams: Record<string, string>) {
     });
     return {
       ok: true,
-      contacts: contacts.map(withGuardianNameOverride),
+      contacts: contacts.map(prepareContactResponse),
     };
   }
 
   const contacts = listContacts(limit, role, contactType);
   return {
     ok: true,
-    contacts: contacts.map(withGuardianNameOverride),
+    contacts: contacts.map(prepareContactResponse),
   };
 }
 
@@ -165,7 +190,7 @@ function handleGetContact(contactId: string) {
       : undefined;
   return {
     ok: true,
-    contact: withGuardianNameOverride(contact),
+    contact: prepareContactResponse(contact),
     assistantMetadata: assistantMeta ?? undefined,
   };
 }
@@ -508,7 +533,7 @@ export const ROUTES: RouteDefinition[] = [
           limit: z.number().optional(),
         })
         .parse(body);
-      return searchContacts(parsed);
+      return searchContacts(parsed).map(prepareContactResponse);
     },
   },
 
@@ -604,7 +629,7 @@ function handleMergeContactsRoute(args: RouteHandlerArgs) {
 
   try {
     const contact = mergeContacts(keepId, mergeId);
-    return { ok: true, contact: withGuardianNameOverride(contact) };
+    return { ok: true, contact: prepareContactResponse(contact) };
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
     throw new BadRequestError(message);
@@ -667,8 +692,6 @@ function handleUpdateContactChannelRoute(args: RouteHandlerArgs) {
   const parentContact = getContact(updated.contactId);
   return {
     ok: true,
-    contact: parentContact
-      ? withGuardianNameOverride(parentContact)
-      : undefined,
+    contact: parentContact ? prepareContactResponse(parentContact) : undefined,
   };
 }

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

@@ -26,6 +26,7 @@ import {
   cancelGeneration,
   clearAllConversations,
   regenerateResponse,
+  resolveMetaSlashCommand,
   switchConversation,
   undoLastMessage,
 } from "../../daemon/handlers/conversations.js";
@@ -93,11 +94,26 @@ function cancelScheduleIfLast(conversationId: string): void {
 function handleCreateConversation({ body = {}, headers }: RouteHandlerArgs) {
   const conversationKey =
     (body.conversationKey as string | undefined) ?? crypto.randomUUID();
+  // The shared route adapter does not runtime-validate the body against the
+  // Zod requestBody (it's codegen-only), so guard the type before trimming —
+  // a malformed `{ title: 123 }` would otherwise throw on `.trim()` and 500.
+  if (body.title !== undefined && typeof body.title !== "string") {
+    throw new BadRequestError("title must be a string");
+  }
+  const customTitle = body.title?.trim() || undefined;
   const result = getOrCreateConversation(conversationKey, {
     conversationType: "standard",
   });
   if (result.created) {
-    updateConversationTitle(result.conversationId, "New Conversation");
+    // A caller-supplied title is user-set: persist it with isAutoTitle = 0 so
+    // the async LLM titler's safe-overwrite check leaves it untouched. Without
+    // one, fall back to the neutral "New Conversation" placeholder, which stays
+    // replaceable by the auto-titler once messages arrive.
+    if (customTitle) {
+      updateConversationTitle(result.conversationId, customTitle, 0);
+    } else {
+      updateConversationTitle(result.conversationId, "New Conversation");
+    }
     publishConversationListAndMetadataChanged(
       "created",
       result.conversationId,
@@ -452,6 +468,29 @@ async function handleUndoLastMessage({ pathParams = {} }: RouteHandlerArgs) {
   };
 }
 
+async function handleResolveMetaSlashCommand({
+  pathParams = {},
+  body = {},
+}: RouteHandlerArgs) {
+  const command = body.command as string | undefined;
+  if (!command || typeof command !== "string") {
+    throw new BadRequestError("Missing command");
+  }
+  let result: Awaited<ReturnType<typeof resolveMetaSlashCommand>>;
+  try {
+    result = await resolveMetaSlashCommand(pathParams.id!, command);
+  } catch (err) {
+    if (err instanceof UserError) {
+      throw new BadRequestError(err.message);
+    }
+    throw err;
+  }
+  if (!result) {
+    throw new NotFoundError(`No conversation for ${pathParams.id}`);
+  }
+  return result;
+}
+
 async function handleRegenerateResponse({ pathParams = {} }: RouteHandlerArgs) {
   const conversationId = pathParams.id!;
   try {
@@ -526,6 +565,12 @@ export const ROUTES: RouteDefinition[] = [
         .literal("standard")
         .optional()
         .describe("Only standard conversations are created by this endpoint"),
+      title: z
+        .string()
+        .optional()
+        .describe(
+          "Explicit title for the conversation. When provided on creation, it is persisted as a user-set title (never overwritten by the auto-titler). Used by flows that mint a conversation up-front and don't want an auto-generated title.",
+        ),
     }),
     responseBody: z.object({
       id: z
@@ -820,6 +865,40 @@ export const ROUTES: RouteDefinition[] = [
     }),
     handler: handleUndoLastMessage,
   },
+  {
+    operationId: "resolveConversationSlashCommand",
+    endpoint: "conversations/:id/slash",
+    method: "POST",
+    policy: {
+      requiredScopes: ["chat.write"],
+      allowedPrincipalTypes: ACTOR_PRINCIPALS,
+    },
+    summary: "Resolve a local meta slash command",
+    description:
+      "Run a local meta slash command (/clean, /status, /commands, /models) " +
+      "without starting a turn: no messages are persisted and no turn events " +
+      "are emitted. /clean also strips runtime injections from the history. " +
+      "Returns the text to render and, for /clean, the post-strip context usage.",
+    tags: ["conversations"],
+    pathParams: [{ name: "id", type: "uuid" }],
+    requestBody: z.object({
+      command: z
+        .string()
+        .describe("The slash command text, e.g. `/clean` or `/status`."),
+    }),
+    responseBody: z.object({
+      kind: z.enum(["clean", "info"]),
+      text: z.string(),
+      contextUsage: z
+        .object({
+          tokens: z.number(),
+          maxTokens: z.number().nullable(),
+          fillRatio: z.number().nullable(),
+        })
+        .optional(),
+    }),
+    handler: handleResolveMetaSlashCommand,
+  },
   {
     operationId: "regenerateResponse",
     endpoint: "conversations/:id/regenerate",

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

@@ -129,9 +129,16 @@ const INFERENCE_PROFILE_UI_KEYS = new Set([
   "speed",
   "verbosity",
   "temperature",
+  "topP",
   "thinking",
 ]);
 
+// Fields a MANAGED profile may edit. Beyond `label` (display name) and
+// `status` (enabled/disabled), users can tune `topP` — the seed contract
+// owns provider/model/connection, but top_p is a per-profile sampling knob
+// the UI exposes on the managed Balanced profile.
+const MANAGED_PROFILE_EDITABLE_KEYS = new Set(["label", "status", "topP"]);
+
 function asMutablePlainObject(value: unknown): Record<string, unknown> | null {
   if (value == null || typeof value !== "object" || Array.isArray(value)) {
     return null;
@@ -508,6 +515,8 @@ const ConfigGetResponseSchema = z
         profiles: z.record(z.string(), WireProfileEntry).optional(),
         profileOrder: z.array(z.string()).optional(),
         activeProfile: z.string().optional(),
+        // The profile the advisor consults; excluded from chat-profile pickers.
+        advisorProfile: z.string().optional(),
         callSites: z
           .record(
             z.string(),
@@ -536,6 +545,13 @@ const ConfigGetResponseSchema = z
           })
           .passthrough()
           .optional(),
+        "web-fetch": z
+          .object({
+            mode: ServiceModeSchema.optional(),
+            provider: z.string().optional(),
+          })
+          .passthrough()
+          .optional(),
         "image-generation": z
           .object({ mode: ServiceModeSchema.optional() })
           .passthrough()
@@ -609,6 +625,7 @@ const ConfigPatchRequestSchema = z
           .optional(),
         profileOrder: z.array(z.string()).optional(),
         activeProfile: z.string().nullable().optional(),
+        advisorProfile: z.string().nullable().optional(),
         callSites: z
           .record(z.string(), CallSiteOverrideDraftSchema.nullable())
           .optional(),
@@ -633,6 +650,14 @@ const ConfigPatchRequestSchema = z
           .passthrough()
           .nullable()
           .optional(),
+        "web-fetch": z
+          .object({
+            mode: ServiceModeSchema.optional(),
+            provider: z.string().optional(),
+          })
+          .passthrough()
+          .nullable()
+          .optional(),
         "image-generation": z
           .object({ mode: ServiceModeSchema.optional() })
           .passthrough()
@@ -730,8 +755,14 @@ function rejectManagedProfileDeletion(body: Record<string, unknown>): void {
   }
   const profiles = asMutablePlainObject(llm.profiles);
   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)) {
+    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.
+    const existing = asMutablePlainObject(existingProfiles[name]);
+    if (existing?.source === "managed") {
       throw new BadRequestError(`Cannot delete managed profile "${name}".`);
     }
   }
@@ -904,21 +935,39 @@ async function handleReplaceInferenceProfile({
     const detail = parsed.error.issues.map((issue) => issue.message).join("; ");
     throw new BadRequestError(`Invalid profile fragment: ${detail}`);
   }
-  const isManaged = MANAGED_PROFILE_NAMES.has(name);
+  // A managed name with no existing entry stays protected so users can't
+  // shadow a seeded managed profile. An existing entry carrying a non-managed
+  // `source` is user-owned and remains fully editable.
+  const existingProfile = asMutablePlainObject(
+    getConfig().llm.profiles?.[name],
+  );
+  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) {
+    throw new BadRequestError(
+      `Profile "${name}" is not currently available and cannot be edited.`,
+    );
+  }
   if (isManaged) {
-    // Managed profiles are daemon-seeded — provider, model, advanced params,
-    // and the connection binding all belong to the seed contract and can't
-    // be reshaped by the user. The two fields that ARE user policy (display
-    // label and enabled status) are allowed through so users can rename a
-    // managed profile or temporarily disable it without duplicating it.
+    // Managed profiles are daemon-seeded — provider, model, and the
+    // connection binding all belong to the seed contract and can't be
+    // reshaped by the user. The fields that ARE user policy (display label,
+    // enabled status, and the topP sampling knob) are allowed through so
+    // users can rename a managed profile, temporarily disable it, or tune
+    // top_p without duplicating it.
     const requestedKeys = Object.keys(parsed.data);
     const disallowed = requestedKeys.filter(
-      (k) => k !== "label" && k !== "status",
+      (k) => !MANAGED_PROFILE_EDITABLE_KEYS.has(k),
     );
     if (disallowed.length > 0) {
       throw new BadRequestError(
         `Cannot edit managed profile "${name}" fields [${disallowed.join(", ")}]. ` +
-          `Only label and status may be edited; duplicate to a custom profile to change other fields.`,
+          `Only label, status, and topP may be edited; duplicate to a custom profile to change other fields.`,
       );
     }
   }
@@ -1019,7 +1068,7 @@ async function handleReplaceInferenceProfile({
 }
 
 /**
- * Apply a `{label?, status?}` patch to a managed profile entry, preserving
+ * Apply a `{label?, status?, topP?}` patch to a managed profile entry, preserving
  * every other field already on disk (provider, model, advanced params, etc).
  * Caller is responsible for having already restricted the fragment to the
  * managed-allowed keys.
@@ -1039,19 +1088,16 @@ function patchManagedProfileFields(
 
   const existingProfile = asMutablePlainObject(profiles[name]) ?? {};
   const nextProfile: Record<string, unknown> = { ...existingProfile };
-  // Send `null` to clear; omit to leave untouched.
-  if ("label" in fragment) {
-    if (fragment.label === null) {
-      delete nextProfile.label;
-    } else {
-      nextProfile.label = fragment.label;
-    }
-  }
-  if ("status" in fragment) {
-    if (fragment.status === null) {
-      delete nextProfile.status;
+  // For each managed-editable key: send `null` to clear, a value to set,
+  // omit to leave untouched. Iterating the allowlist keeps persistence in
+  // lock-step with the guard above — a key can't slip through the gate
+  // without also being written.
+  for (const key of MANAGED_PROFILE_EDITABLE_KEYS) {
+    if (!(key in fragment)) continue;
+    if (fragment[key] === null) {
+      delete nextProfile[key];
     } else {
-      nextProfile.status = fragment.status;
+      nextProfile[key] = fragment[key];
     }
   }
   profiles[name] = nextProfile;