@vellumai/assistant 0.11.1-dev.202608041245.b3413fb → 0.11.1-dev.202608041551.40f0fbf

package/openapi.yaml

@@ -14637,7 +14637,9 @@ paths:
         "404":
           description: Profile not found
         "409":
-          description: Profile is still referenced by activeProfile, advisorProfile, a call site, or a mix arm
+          description:
+            Profile is still referenced by activeProfile, advisorProfile, a call site, a default-tier override, or a
+            mix arm
     get:
       operationId: inference_profiles_by_name_get
       summary: Get an effective inference profile
@@ -27286,10 +27288,13 @@ paths:
                     type: string
                   name:
                     type: string
+                  error:
+                    description:
+                      Why the secret was not stored (e.g. provider-side API key validation failed). Present only when success is
+                      false.
+                    type: string
                 required:
                   - success
-                  - type
-                  - name
                 additionalProperties: false
   /v1/secrets/read:
     post:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.11.1-dev.202608041245.b3413fb",
+  "version": "0.11.1-dev.202608041551.40f0fbf",
   "license": "MIT",
   "type": "module",
   "exports": {

package/src/__tests__/conversation-queue.test.ts

@@ -12,6 +12,7 @@ import type {
 import type { AssistantEvent } from "../api/index.js";
 import type { Message, ProviderResponse } from "../providers/types.js";
 import { stampAndBuffer } from "../runtime/assistant-stream-state.js";
+import { createAbortReason } from "../util/abort-reasons.js";
 import { setConfig } from "./helpers/set-config.js";
 
 // ---------------------------------------------------------------------------
@@ -826,7 +827,7 @@ describe("Conversation message queue", () => {
     await new Promise((r) => setTimeout(r, 10));
   });
 
-  test("abort() clears the queue and sends generation_cancelled for each queued message", async () => {
+  test("abort() clears the queue and closes out each queued message", async () => {
     const conversation = makeConversation();
     await conversation.loadFromDb();
 
@@ -873,6 +874,17 @@ describe("Conversation message queue", () => {
       conversationId: "conv-1",
     });
 
+    // Each discarded row also gets its own terminal event. `generation_cancelled`
+    // closes out the turn they were waiting on; only `message_queued_deleted`
+    // closes out the queued rows themselves, and without it clients keep the
+    // pending indicator up forever, since no `message_dequeued` is coming.
+    expect(
+      events2.find((e) => e.type === "message_queued_deleted"),
+    ).toMatchObject({ conversationId: "conv-1", requestId: "req-2" });
+    expect(
+      events3.find((e) => e.type === "message_queued_deleted"),
+    ).toMatchObject({ conversationId: "conv-1", requestId: "req-3" });
+
     // abort() must NOT emit conversation_error or generic error for queued discards.
     const err2 = events2.find((e) => e.type === "error");
     expect(err2).toBeUndefined();
@@ -897,6 +909,122 @@ describe("Conversation message queue", () => {
     await new Promise((r) => setTimeout(r, 10));
   });
 
+  test("a user interrupt keeps the queue and the stopped turn's drain sends it", async () => {
+    // GIVEN a turn in flight with a message queued behind it
+    const conversation = makeConversation();
+    await conversation.loadFromDb();
+
+    const events2: AssistantEvent[] = [];
+    conversation.processMessage({
+      content: "msg-1",
+      attachments: [],
+      requestId: "req-1",
+    });
+    await waitForPendingRun(1);
+
+    conversation.enqueueMessage({
+      content: "msg-2",
+      onEvent: (e) => events2.push(e),
+      requestId: "req-2",
+    });
+    expect(conversation.getQueueDepth()).toBe(1);
+
+    // WHEN the user hits Stop
+    conversation.abort(
+      createAbortReason("user_cancel", "conversation-queue.test", "conv-1"),
+    );
+
+    // THEN the queued message survives the abort. Stop ends the turn the user
+    // is watching, not the message they queued behind it, and a discard here
+    // reaches no client: it emits no per-row terminal event.
+    expect(conversation.getQueueDepth()).toBe(1);
+    expect(
+      events2.find((e) => e.type === "generation_cancelled"),
+    ).toBeUndefined();
+    expect(
+      events2.find((e) => e.type === "message_queued_deleted"),
+    ).toBeUndefined();
+
+    // AND once the stopped turn unwinds, its `finally` drains the queue, so the
+    // message is sent instead of needing to be retyped.
+    await resolveRun(0);
+    await waitForPendingRun(2);
+    expect(events2.find((e) => e.type === "message_dequeued")).toMatchObject({
+      conversationId: "conv-1",
+      requestId: "req-2",
+    });
+    expect(conversation.getQueueDepth()).toBe(0);
+    expect(
+      JSON.stringify(
+        pendingRuns[1].messages[pendingRuns[1].messages.length - 1],
+      ),
+    ).toContain("msg-2");
+
+    await resolveRun(1);
+    await new Promise((r) => setTimeout(r, 10));
+  });
+
+  test("a user interrupt mid-tool repairs the abandoned tool_use before the queued message runs", async () => {
+    // GIVEN a turn whose history ends with an unanswered tool_use, the shape a
+    // Stop mid-tool-call leaves behind and which providers reject outright
+    const conversation = makeConversation();
+    await conversation.loadFromDb();
+
+    const events2: AssistantEvent[] = [];
+    conversation.processMessage({
+      content: "msg-1",
+      attachments: [],
+      requestId: "req-1",
+    });
+    await waitForPendingRun(1);
+
+    conversation.enqueueMessage({
+      content: "msg-2",
+      onEvent: (e) => events2.push(e),
+      requestId: "req-2",
+    });
+
+    // WHEN the user interrupts and the stopped turn unwinds with the tool call
+    // still unanswered, then drains the queue
+    conversation.abort(
+      createAbortReason("user_cancel", "conversation-queue.test", "conv-1"),
+    );
+    const interrupted = pendingRuns[0];
+    await interrupted.onEvent({ type: "llm_call_started" });
+    interrupted.resolve([
+      ...interrupted.messages,
+      {
+        role: "assistant",
+        content: [
+          {
+            type: "tool_use",
+            id: "toolu-interrupted",
+            name: "bash",
+            input: {},
+          },
+        ],
+      },
+    ]);
+    await waitForPendingRun(2);
+
+    // THEN the drained turn opens with a synthetic result for the abandoned
+    // call rather than a dangling tool_use.
+    const repaired = pendingRuns[1].messages.find(
+      (m) =>
+        m.role === "user" &&
+        m.content.some(
+          (block) =>
+            block.type === "tool_result" &&
+            block.tool_use_id === "toolu-interrupted",
+        ),
+    );
+    expect(repaired).toBeDefined();
+    expect(conversation.pendingInterruptRepair).toBe(false);
+
+    await resolveRun(1);
+    await new Promise((r) => setTimeout(r, 10));
+  });
+
   test("conversation-scoped errors emit both conversation_error and generic error", async () => {
     const conversation = makeConversation();
     await conversation.loadFromDb();

package/src/__tests__/llm-resolver-override-or-default.test.ts

@@ -530,3 +530,82 @@ describe("user shadows of default keys keep their intent", () => {
     expect(pinned.provider).toBe("openai");
   });
 });
+
+describe("defaultProfileOverrides tier remap", () => {
+  test("a tier remap redirects every call site on that tier, and only that tier", () => {
+    const llm = LLMSchema.parse({
+      profiles: { mine: completeCustom },
+      defaultProfileOverrides: { "cost-optimized": "mine" },
+      ...anthropicDp,
+    });
+    // conversationSummarization ships on the cost-optimized tier.
+    const resolved = resolveCallSiteConfig("conversationSummarization", llm);
+    expect(resolved.model).toBe("gpt-5.5");
+    expect(resolved.provider).toBe("openai");
+    const selection = selectWinningProfile("conversationSummarization", llm);
+    expect(selection.profileName).toBe("mine");
+    expect(selection.source).toBe("default");
+    // A balanced-tier site is untouched by a cost-optimized remap.
+    expect(resolveCallSiteConfig("subagentSpawn", llm).provider).toBe(
+      "anthropic",
+    );
+  });
+
+  test("a per-call-site pin still beats the tier remap", () => {
+    const llm = LLMSchema.parse({
+      profiles: {
+        mine: completeCustom,
+        pinned: { ...completeCustom, model: "gpt-5.4" },
+      },
+      defaultProfileOverrides: { "cost-optimized": "mine" },
+      callSites: { conversationSummarization: { profile: "pinned" } },
+      ...anthropicDp,
+    });
+    expect(resolveCallSiteConfig("conversationSummarization", llm).model).toBe(
+      "gpt-5.4",
+    );
+  });
+
+  test("an unusable remap target reports and falls through to the stock tier", () => {
+    const llm = LLMSchema.parse({
+      profiles: { partial: { source: "user", model: "gpt-5.5" } },
+      defaultProfileOverrides: { "cost-optimized": "partial" },
+      ...anthropicDp,
+    });
+    const { fallbacks, opts } = collect();
+    const resolved = resolveCallSiteConfig(
+      "conversationSummarization",
+      llm,
+      opts,
+    );
+    expect(resolved.provider).toBe("anthropic");
+    expect(fallbacks).toContainEqual({
+      callSite: "conversationSummarization",
+      requested: "partial",
+      reason: "incomplete",
+    });
+  });
+
+  test("the anchor consults the balanced remap for profileless call sites", () => {
+    const llm = LLMSchema.parse({
+      profiles: { mine: completeCustom },
+      defaultProfileOverrides: { balanced: "mine" },
+      ...anthropicDp,
+    });
+    // `vision` has no shipped profile; it resolves through the anchor.
+    expect(resolveCallSiteConfig("vision", llm).model).toBe("gpt-5.5");
+    expect(selectWinningProfile("vision", llm).profileName).toBe("mine");
+  });
+
+  test("a self-referential remap is a no-op", () => {
+    const llm = LLMSchema.parse({
+      defaultProfileOverrides: { balanced: "balanced" },
+      ...anthropicDp,
+    });
+    const { fallbacks, opts } = collect();
+    expect(resolveCallSiteConfig("subagentSpawn", llm, opts).provider).toBe(
+      "anthropic",
+    );
+    expect(fallbacks).toEqual([]);
+  });
+});

package/src/__tests__/llm-resolver.test.ts

@@ -385,6 +385,7 @@ describe("resolveCallSiteConfig", () => {
       callSites: {
         mainAgent: { profile: "nonexistent" },
       },
+      defaultProfileOverrides: {},
       profileSession: { defaultTtlSeconds: 1800, maxTtlSeconds: 43200 },
       pricingOverrides: [],
     };
@@ -561,6 +562,7 @@ describe("resolveCallSiteConfig", () => {
       profileOrder: [],
       callSites: {},
       activeProfile: "nonexistent",
+      defaultProfileOverrides: {},
       profileSession: { defaultTtlSeconds: 1800, maxTtlSeconds: 43200 },
       pricingOverrides: [],
     };

package/src/__tests__/llm-schema.test.ts

@@ -319,4 +319,40 @@ describe("LLMSchema", () => {
     });
     expect(result.success).toBe(true);
   });
+
+  test("defaultProfileOverrides accepts custom profiles and default keys as targets", () => {
+    const parsed = LLMSchema.parse({
+      profiles: { fast: { speed: "fast", effort: "low" } },
+      defaultProfileOverrides: {
+        balanced: "fast",
+        "cost-optimized": "quality-optimized",
+      },
+    });
+    expect(parsed.defaultProfileOverrides).toEqual({
+      balanced: "fast",
+      "cost-optimized": "quality-optimized",
+    });
+    expect(LLMSchema.parse({}).defaultProfileOverrides).toEqual({});
+  });
+
+  test("a defaultProfileOverrides target naming no profile is rejected", () => {
+    const result = LLMSchema.safeParse({
+      defaultProfileOverrides: { balanced: "no-such-profile" },
+    });
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(result.error.issues[0]?.path).toEqual([
+        "defaultProfileOverrides",
+        "balanced",
+      ]);
+    }
+  });
+
+  test("a defaultProfileOverrides key outside the default-profile tiers is rejected", () => {
+    const result = LLMSchema.safeParse({
+      profiles: { fast: { speed: "fast" } },
+      defaultProfileOverrides: { turbo: "fast" },
+    });
+    expect(result.success).toBe(false);
+  });
 });

package/src/cli/commands/mcp.help.ts

@@ -128,8 +128,10 @@ Arguments:
   name   Name of a configured MCP server to authenticate with
 
 Only works with sse or streamable-http transports (stdio servers do not use
-OAuth). Opens a browser for OAuth authorization with the remote server. The
-running assistant handles the OAuth callback and token exchange.
+OAuth). On desktop, opens a browser for OAuth authorization with the remote
+server. On web, prints the OAuth URL to the terminal — copy and open it in a
+new browser tab manually. The running assistant handles the OAuth callback
+and token exchange in both cases.
 
 The command waits up to 2.5 minutes for the user to complete the browser-based
 OAuth flow. If the server already has valid cached tokens, the command succeeds

package/src/config/__tests__/sync-gated-profiles.test.ts

@@ -340,6 +340,31 @@ describe("reconcileFlagGatedProfiles", () => {
     expect(LLMSchema.safeParse(after.llm).success).toBe(true);
   });
 
+  test("flag off clears a tier override targeting os-beta", () => {
+    process.env.IS_PLATFORM = "true";
+    seedBalancedConfig();
+    setOverridesForTesting({ "os-beta": true });
+    reconcileFlagGatedProfiles();
+
+    const raw = readConfig();
+    (raw.llm as Record<string, unknown>).defaultProfileOverrides = {
+      balanced: "os-beta",
+      "cost-optimized": "quality-optimized",
+    };
+    writeConfig(raw);
+    invalidateConfigCache();
+
+    setOverridesForTesting({ "os-beta": false });
+    expect(reconcileFlagGatedProfiles()).toBe(true);
+
+    const after = readConfig();
+    expect(
+      (after.llm as Record<string, unknown>).defaultProfileOverrides,
+    ).toEqual({ "cost-optimized": "quality-optimized" });
+
+    expect(LLMSchema.safeParse(after.llm).success).toBe(true);
+  });
+
   test("a user-owned os-beta profile is never touched", () => {
     process.env.IS_PLATFORM = "true";
     writeConfig({

package/src/config/llm-resolver.ts

@@ -38,10 +38,12 @@ import {
  *   2. `llm.activeProfile` — `mainAgent` only, since it IS that call site's
  *      user-facing chat-model selection
  *   3. `llm.callSites[callSite].profile` (the call site's named profile)
- *   4. `CALL_SITE_DEFAULTS[callSite].profile` intent resolved through
- *      `llm.defaultProvider`
- *   5. balanced intent through `llm.defaultProvider` — the code-owned anchor
- *      for profileless call sites, or when nothing above is usable
+ *   4. `CALL_SITE_DEFAULTS[callSite].profile` intent, remapped through
+ *      `llm.defaultProfileOverrides[intent]` when set, otherwise resolved
+ *      through `llm.defaultProvider`
+ *   5. balanced intent (same remap consult) through `llm.defaultProvider`:
+ *      the code-owned anchor for profileless call sites, or when nothing
+ *      above is usable
  *
  * A winner must carry its own `provider` AND `model`: the base layer's schema
  * default identity never stands in for a selected profile. The anchor is
@@ -147,9 +149,11 @@ export function resolveCallSiteConfig(
 //   1. `opts.overrideProfile` (conversation/schedule/per-turn pin)
 //   2. `llm.activeProfile` (mainAgent only — it IS that call site's selection)
 //   3. `llm.callSites[callSite].profile`
-//   4. `CALL_SITE_DEFAULTS[callSite].profile` intent × default provider
-//   5. balanced intent × default provider (profileless sites, or nothing
-//      above usable)
+//   4. `CALL_SITE_DEFAULTS[callSite].profile` intent, remapped via
+//      `llm.defaultProfileOverrides[intent]` when set, else intent × default
+//      provider
+//   5. balanced intent (same remap consult) × default provider (profileless
+//      sites, or nothing above usable)
 // A winner must carry its own `provider` AND `model`: the base layer's
 // schema-default identity must never stand in for a selected profile (that
 // would be merge inheritance by the back door). A fallback anchor must be
@@ -212,8 +216,28 @@ export function selectWinningProfile(
       entry: sitePin.entry,
     };
   }
+  // A tier remap (`llm.defaultProfileOverrides`) redirects the intent rung
+  // to a named profile. Resolved through the same `usableEntry` gate as
+  // every other rung, so an unusable target reports and falls through to
+  // the stock tier resolution. A self-reference is skipped rather than
+  // resolved: the stock rung's handling of unusable user shadows differs
+  // from the named-rung path, and a no-op remap must not change behavior.
+  const remappedIntent = (intent: string) => {
+    if (!isDefaultProfileKey(intent)) {
+      return undefined;
+    }
+    const target = llm.defaultProfileOverrides?.[intent];
+    return target === intent
+      ? undefined
+      : usableEntry(target, llm, opts, report);
+  };
+
   const intent = CALL_SITE_DEFAULTS[callSite]?.profile;
   if (intent != null) {
+    const remap = remappedIntent(intent);
+    if (remap) {
+      return { profileName: remap.name, source: "default", entry: remap.entry };
+    }
     const entry = usableDefaultIntent(intent, llm, opts, report);
     if (entry) {
       return { profileName: intent, source: "default", entry };
@@ -221,8 +245,19 @@ export function selectWinningProfile(
   }
   // Anchor: profileless call sites (`vision`, `workflowLeaf`) and any
   // resolution whose every named rung was unusable land on balanced intent
-  // through the default provider. `profileName` stays null — the anchor is
-  // not a selection.
+  // through the default provider. The anchor consults the balanced remap
+  // first (a profileless call site follows the user's balanced choice like
+  // any balanced-tier site) but bottoms out on the code-owned catalog, so
+  // it always resolves. `profileName` stays null on the catalog path: the
+  // anchor itself is not a selection.
+  const anchorRemap = remappedIntent("balanced");
+  if (anchorRemap) {
+    return {
+      profileName: anchorRemap.name,
+      source: "default",
+      entry: anchorRemap.entry,
+    };
+  }
   return {
     profileName: null,
     source: "default",

package/src/config/schemas/llm.ts

@@ -657,6 +657,15 @@ export const LLMSchema = z
     // are seeded into the user's on-disk config by migration 040, not at
     // schema level, so `LLMSchema.parse({})` yields an empty map.
     callSites: z.partialRecord(LLMCallSiteEnum, LLMCallSiteConfig).default({}),
+    // Per-tier remap of the shipped call-site defaults: every call site whose
+    // `CALL_SITE_DEFAULTS` profile is <tier> resolves through the named
+    // profile instead of the tier's intent × provider matrix body. A
+    // per-call-site pin (`llm.callSites.*.profile`) still wins over the
+    // remap, and an unusable remap target falls through to the stock tier
+    // resolution (see `selectWinningProfile`).
+    defaultProfileOverrides: z
+      .partialRecord(z.enum(DEFAULT_PROFILE_KEYS), z.string().min(1))
+      .default({}),
     activeProfile: z.string().min(1).optional(),
     // The profile the advisor role consults when spawned as a subagent (chosen
     // under Models & Services). It is excluded from the chat-profile pickers so
@@ -725,6 +734,17 @@ export const LLMSchema = z
         });
       }
     }
+    for (const [tier, profileName] of Object.entries(
+      config.defaultProfileOverrides ?? {},
+    )) {
+      if (profileName != null && !profileNames.has(profileName)) {
+        ctx.addIssue({
+          code: "custom",
+          path: ["defaultProfileOverrides", tier],
+          message: `Profile "${profileName}" referenced by llm.defaultProfileOverrides.${tier} is not defined in llm.profiles`,
+        });
+      }
+    }
     if (
       config.activeProfile != null &&
       !profileNames.has(config.activeProfile)

package/src/config/sync-gated-profiles.ts

@@ -221,5 +221,16 @@ function disableProfile(
     }
   }
 
+  // Clear any tier override targeting a removed profile; the cleared tier
+  // falls back to its stock intent resolution.
+  const tierOverrides = readObject(llm.defaultProfileOverrides);
+  if (tierOverrides) {
+    for (const [tier, target] of Object.entries(tierOverrides)) {
+      if (typeof target === "string" && removed.has(target)) {
+        delete tierOverrides[tier];
+      }
+    }
+  }
+
   return true;
 }

package/src/daemon/__tests__/abort-null-controller.test.ts

@@ -37,25 +37,41 @@ mock.module("../../messaging/providers/telegram-bot/render.js", () => ({
 }));
 
 const { abortConversation } = await import("../conversation-lifecycle.js");
+import { createAbortReason } from "../../util/abort-reasons.js";
 import type { AbortContext } from "../conversation-lifecycle.js";
 
+interface QueuedEvent {
+  type: string;
+  requestId?: string;
+}
+
 interface Harness {
   ctx: AbortContext;
   setProcessingCalls: boolean[];
   prompterDisposed: () => boolean;
   secretPrompterDisposed: () => boolean;
   queueClearedCount: () => number;
+  queuedEvents: QueuedEvent[];
+  drainKicks: string[];
 }
 
 function makeContext(opts: {
   processing: boolean;
   controller: AbortController | null;
+  /** requestIds of messages sitting in the queue behind the aborted turn. */
+  queued?: string[];
 }): Harness {
   let processing = opts.processing;
   const setProcessingCalls: boolean[] = [];
   let prompterDisposed = false;
   let secretPrompterDisposed = false;
   let queueCleared = 0;
+  const queuedEvents: QueuedEvent[] = [];
+  const drainKicks: string[] = [];
+  let queuedItems = (opts.queued ?? []).map((requestId) => ({
+    requestId,
+    onEvent: (event: QueuedEvent) => queuedEvents.push(event),
+  }));
 
   const ctx = {
     conversationId: "abort-null-controller-test",
@@ -82,10 +98,19 @@ function makeContext(opts: {
     queue: {
       clear: () => {
         queueCleared += 1;
+        queuedItems = [];
+      },
+      get isEmpty() {
+        return queuedItems.length === 0;
       },
-      [Symbol.iterator]: function* () {
-        // no queued messages
+      get length() {
+        return queuedItems.length;
       },
+      [Symbol.iterator]: () => queuedItems[Symbol.iterator](),
+    },
+    pendingInterruptRepair: false,
+    kickDrainQueue: async (_reason?: string, origin?: string) => {
+      drainKicks.push(origin ?? "");
     },
   } as unknown as AbortContext;
 
@@ -95,6 +120,8 @@ function makeContext(opts: {
     prompterDisposed: () => prompterDisposed,
     secretPrompterDisposed: () => secretPrompterDisposed,
     queueClearedCount: () => queueCleared,
+    queuedEvents,
+    drainKicks,
   };
 }
 
@@ -152,6 +179,114 @@ describe("abortConversation", () => {
     );
   });
 
+  test("a user interrupt leaves queued messages for the stopped turn's drain", () => {
+    // GIVEN a live turn with two messages queued behind it
+    const controller = new AbortController();
+    const h = makeContext({
+      processing: true,
+      controller,
+      queued: ["req-a", "req-b"],
+    });
+
+    // WHEN the user stops the turn
+    abortConversation(
+      h.ctx,
+      createAbortReason("user_cancel", "test", "abort-null-controller-test"),
+    );
+
+    // THEN the queue is untouched, so the agent loop's `finally` drains it and
+    // the queued messages are sent rather than silently dropped
+    expect(h.queueClearedCount()).toBe(0);
+    expect(h.ctx.queue.length).toBe(2);
+    expect(h.queuedEvents).toEqual([]);
+    // AND the drain is left to that `finally`, not kicked from here
+    expect(h.drainKicks).toEqual([]);
+    // AND the drain is told to repair tool_use blocks the killed turn abandoned
+    expect(h.ctx.pendingInterruptRepair).toBe(true);
+  });
+
+  test("a user interrupt with no live turn kicks the drain itself", () => {
+    // GIVEN a conversation flagged processing with no controller left to
+    // signal, so no agent-loop `finally` is coming to drain the preserved queue
+    const h = makeContext({
+      processing: true,
+      controller: null,
+      queued: ["req-a"],
+    });
+
+    // WHEN the user stops it
+    abortConversation(
+      h.ctx,
+      createAbortReason("user_cancel", "test", "abort-null-controller-test"),
+    );
+
+    // THEN the queued message is still sent, because the abort kicks the drain
+    expect(h.ctx.queue.length).toBe(1);
+    expect(h.drainKicks).toEqual(["abortConversation:no_live_turn"]);
+  });
+
+  test("a non-interrupt abort discards the queue and closes out each row", () => {
+    // GIVEN a live turn with a queued message, torn down by a dispose
+    const controller = new AbortController();
+    const h = makeContext({
+      processing: true,
+      controller,
+      queued: ["req-a"],
+    });
+
+    // WHEN the conversation is disposed rather than interrupted
+    abortConversation(
+      h.ctx,
+      createAbortReason(
+        "conversation_disposed",
+        "test",
+        "abort-null-controller-test",
+      ),
+    );
+
+    // THEN the queue is dropped, since no turn is left for it to run on, and
+    // the sender gets the terminal event that closes the queued row, so no
+    // client is left holding a pending indicator nothing will ever settle
+    expect(h.queueClearedCount()).toBe(1);
+    expect(h.queuedEvents.map((e) => e.type)).toEqual([
+      "generation_cancelled",
+      "message_queued_deleted",
+    ]);
+    expect(h.queuedEvents[1].requestId).toBe("req-a");
+    expect(h.ctx.pendingInterruptRepair).toBe(false);
+  });
+
+  test("a teardown abort discards the queue even when the flag reads idle", () => {
+    // GIVEN a conversation whose turn already cleared the processing flag but
+    // is still unwinding: the agent-loop `finally` clears the flag, then awaits
+    // the turn-boundary commit before its `kickDrainQueue`. A dispose landing
+    // in that window sees an idle conversation with a populated queue.
+    const h = makeContext({
+      processing: false,
+      controller: null,
+      queued: ["req-a"],
+    });
+
+    // WHEN the conversation is disposed
+    abortConversation(
+      h.ctx,
+      createAbortReason(
+        "conversation_disposed",
+        "test",
+        "abort-null-controller-test",
+      ),
+    );
+
+    // THEN the queue goes with it, so the pending `kickDrainQueue` finds
+    // nothing to run against the disposed conversation, and the queued row
+    // still gets its terminal event
+    expect(h.ctx.queue.length).toBe(0);
+    expect(h.queuedEvents.map((e) => e.type)).toEqual([
+      "generation_cancelled",
+      "message_queued_deleted",
+    ]);
+  });
+
   test("clears the persisted flag when in-memory reads idle (cancel with no live abort)", () => {
     // GIVEN a conversation whose in-memory flag reads idle — e.g. reloaded
     // after its owning turn was interrupted out-of-process, so a persisted
@@ -166,9 +301,10 @@ describe("abortConversation", () => {
     // persisted column, so the row is unwedged for cold readers and the next
     // reload — cancel is not a silent no-op.
     expect(h.setProcessingCalls).toEqual([false]);
-    // AND the live-turn teardown (prompters, queue) is left alone: there was no
-    // live turn holding them.
+    // AND the live-turn teardown (prompters, surfaces) is left alone: there was
+    // no live turn holding them. The queue is the exception, discarded on any
+    // non-interrupt abort regardless of the flag.
     expect(h.prompterDisposed()).toBe(false);
-    expect(h.queueClearedCount()).toBe(0);
+    expect(h.ctx.queue.length).toBe(0);
   });
 });

package/src/daemon/conversation-lifecycle.ts

@@ -12,6 +12,7 @@ import { getConfig } from "../config/loader.js";
 import { usesConceptPageMemory } from "../config/memory-v3-gate.js";
 import type { PermissionPrompter } from "../permissions/prompter.js";
 import type { SecretPrompter } from "../permissions/secret-prompter.js";
+import { isHiddenMessageMetadata } from "../persistence/conversation-types.js";
 import {
   enqueueMemoryJob,
   isMemoryEnabled,
@@ -23,10 +24,17 @@ import { resolveCapabilities } from "../runtime/capabilities.js";
 import { isAutoAnalysisConversation } from "../runtime/services/auto-analysis-guard.js";
 import { unregisterConversationSender } from "../tools/browser/browser-screencast.js";
 import { disposeToolProfiler } from "../tools/tool-profiler.js";
-import { type AbortReason, createAbortReason } from "../util/abort-reasons.js";
+import {
+  type AbortReason,
+  createAbortReason,
+  isUserInterruptAbort,
+} from "../util/abort-reasons.js";
 import { getLogger } from "../util/logger.js";
 import { unregisterCallNotifiers } from "./conversation-notifiers.js";
-import type { MessageQueue } from "./conversation-queue-manager.js";
+import type {
+  MessageQueue,
+  QueueDrainReason,
+} from "./conversation-queue-manager.js";
 import { resetSkillToolProjection } from "./conversation-skill-tools.js";
 import type { SurfaceData, SurfaceType } from "./message-protocol.js";
 
@@ -112,6 +120,12 @@ export interface AbortContext {
   >;
   accumulatedSurfaceState: Map<string, Record<string, unknown>>;
   readonly queue: MessageQueue;
+  /** Armed when an interrupt leaves queued messages behind, so the drain
+   *  repairs tool_use blocks the killed turn abandoned. */
+  pendingInterruptRepair: boolean;
+  /** Never rejects. Called only when an interrupt preserves the queue but no
+   *  live turn is left to reach its `finally` and drain it. */
+  kickDrainQueue(reason?: QueueDrainReason, origin?: string): Promise<void>;
 }
 
 export interface DisposeContext extends AbortContext {
@@ -129,18 +143,99 @@ export interface DisposeContext extends AbortContext {
 
 // ── abort ─────────────────────────────────────────────────────────────
 
+/**
+ * Keep the queue intact across a user interrupt so the messages queued behind
+ * the stopped turn still run.
+ *
+ * A user interrupt ends the turn in flight and nothing else: the aborted turn
+ * unwinds to the agent loop's `finally`, which calls `kickDrainQueue`, so the
+ * queued messages become the next turn. This is the same drain-after-abort
+ * sequence `steerToMessage` relies on.
+ *
+ * An interrupt can land mid-tool, leaving `tool_use` blocks with no results, so
+ * arm the same repair a steer arms: the drained turn then opens with synthetic
+ * results instead of a dangling call.
+ *
+ * `hasLiveTurn` is false when the processing flag was force-cleared because no
+ * controller was left to signal. No agent-loop `finally` runs in that case, so
+ * the drain is kicked here instead; otherwise the preserved messages wait for
+ * an unrelated later turn to finish.
+ */
+function preserveQueueAcrossInterrupt(
+  ctx: AbortContext,
+  { hasLiveTurn }: { hasLiveTurn: boolean },
+): void {
+  if (ctx.queue.isEmpty) {
+    return;
+  }
+  ctx.pendingInterruptRepair = true;
+  log.info(
+    {
+      conversationId: ctx.conversationId,
+      queueDepth: ctx.queue.length,
+      hasLiveTurn,
+    },
+    "User interrupt: preserving queued messages for the interrupted turn's drain",
+  );
+  if (!hasLiveTurn) {
+    void ctx.kickDrainQueue("loop_complete", "abortConversation:no_live_turn");
+  }
+}
+
+/**
+ * Discard the queue when the conversation itself is going away (dispose,
+ * eviction, voice supersession, subagent teardown): there is no turn left for
+ * a queued message to run on.
+ *
+ * This runs whether or not the in-memory flag reads processing. A turn that
+ * cleared the flag can still be unwinding through its awaited turn-boundary
+ * commit with a `kickDrainQueue` ahead of it, and a queue left populated there
+ * drains onto a conversation whose state (and possibly whose durable row) is
+ * already gone.
+ *
+ * Each sender gets two events, both load-bearing. `generation_cancelled`
+ * closes out the turn the message was waiting on; `message_queued_deleted` is
+ * the terminal event for the queued row itself, the same one a user-issued
+ * DELETE emits (`deleteQueuedMessage`). Without the second, a client holds the
+ * pending indicator forever, since no `message_dequeued` is coming. Hidden
+ * sends are suppressed for the same reason they get no queued ack: they have
+ * no client row to close.
+ */
+function discardQueueOnAbort(ctx: AbortContext): void {
+  for (const queued of ctx.queue) {
+    queued.onEvent({
+      type: "generation_cancelled",
+      conversationId: ctx.conversationId,
+    });
+    if (isHiddenMessageMetadata(queued.metadata)) {
+      continue;
+    }
+    queued.onEvent({
+      type: "message_queued_deleted",
+      conversationId: ctx.conversationId,
+      requestId: queued.requestId,
+      ...(queued.clientMessageId
+        ? { clientMessageId: queued.clientMessageId }
+        : {}),
+    });
+  }
+  ctx.queue.clear();
+}
+
 export function abortConversation(
   ctx: AbortContext,
   reason?: AbortReason,
 ): void {
-  if (ctx.isProcessing()) {
-    const effectiveReason =
-      reason ??
-      createAbortReason(
-        "preempted_by_new_message",
-        "abortConversation:default",
-        ctx.conversationId,
-      );
+  const effectiveReason =
+    reason ??
+    createAbortReason(
+      "preempted_by_new_message",
+      "abortConversation:default",
+      ctx.conversationId,
+    );
+  const hasLiveTurn = ctx.abortController !== null;
+  const wasProcessing = ctx.isProcessing();
+  if (wasProcessing) {
     log.info(
       { conversationId: ctx.conversationId, abortReason: effectiveReason },
       "Aborting in-flight processing",
@@ -175,13 +270,6 @@ export function abortConversation(
     ctx.surfaceActionRequestIds.clear();
     ctx.surfaceState.clear();
     ctx.accumulatedSurfaceState.clear();
-    for (const queued of ctx.queue) {
-      queued.onEvent({
-        type: "generation_cancelled",
-        conversationId: ctx.conversationId,
-      });
-    }
-    ctx.queue.clear();
   } else {
     // The in-memory flag reads idle, but a cancel must still clear a persisted
     // `processing_started_at` that outlived the turn that set it. This is the
@@ -201,6 +289,20 @@ export function abortConversation(
     // reports idle in-memory to clients, so no refetch needs to be pushed.
     ctx.setProcessing(false);
   }
+
+  // The queue decision is independent of the processing flag: an interrupt
+  // hands its queue to the drain, and every other abort kind is a teardown
+  // that must take the queue with it even when the flag already reads idle.
+  if (isUserInterruptAbort(effectiveReason)) {
+    // An idle conversation counts as having a live turn for drain purposes:
+    // either a turn is unwinding toward its own `kickDrainQueue`, or the queue
+    // is empty. Kicking a second drain here would race the first.
+    preserveQueueAcrossInterrupt(ctx, {
+      hasLiveTurn: hasLiveTurn || !wasProcessing,
+    });
+  } else {
+    discardQueueOnAbort(ctx);
+  }
 }
 
 // ── dispose ──────────────────────────────────────────────────────────

package/src/daemon/conversation-process.ts

@@ -324,10 +324,11 @@ async function buildPassthroughBatch(
   return conversation.queue.shiftN(matched);
 }
 
-// ── Steer repair ────────────────────────────────────────────────────
+// ── Steer / interrupt repair ────────────────────────────────────────
 
 /**
- * When a steer-to-message abort interrupts an in-flight tool call, the
+ * When a steer-to-message abort (or a user interrupt with messages still
+ * queued behind the stopped turn) cuts off an in-flight tool call, the
  * conversation history may end with an assistant message containing one
  * or more `tool_use` blocks that have no corresponding `tool_result`.
  * LLM providers reject this sequence. This helper scans the tail of the
@@ -335,10 +336,12 @@ async function buildPassthroughBatch(
  * unmatched `tool_use` blocks.
  */
 function repairPendingToolUseBlocks(conversation: Conversation): void {
-  if (!conversation.pendingSteerRepair) {
+  const steered = conversation.pendingSteerRepair;
+  if (!steered && !conversation.pendingInterruptRepair) {
     return;
   }
   conversation.pendingSteerRepair = false;
+  conversation.pendingInterruptRepair = false;
 
   const messages = conversation.messages;
   if (messages.length === 0) {
@@ -381,15 +384,18 @@ function repairPendingToolUseBlocks(conversation: Conversation): void {
     {
       conversationId: conversation.conversationId,
       pendingToolUseCount: pendingToolUseIds.length,
+      trigger: steered ? "steer" : "interrupt",
     },
-    "Injecting synthetic tool_result for pending tool_use blocks after steer",
+    "Injecting synthetic tool_result for pending tool_use blocks",
   );
 
   // Build a single user message with tool_result blocks for all pending IDs.
   const syntheticContent = pendingToolUseIds.map((toolUseId) => ({
     type: "tool_result" as const,
     tool_use_id: toolUseId,
-    content: "Tool execution was interrupted by user steering.",
+    content: steered
+      ? "Tool execution was interrupted by user steering."
+      : "Tool execution was interrupted by the user.",
     is_error: true,
   }));
   conversation.messages.push({

package/src/daemon/conversation.ts

@@ -538,6 +538,18 @@ export class Conversation {
    * @internal
    */
   pendingSteerRepair = false;
+  /**
+   * Set by `abortConversation` when a user interrupt (Stop / Esc / the CLI
+   * cancel signal) ends a turn that still has messages queued behind it. Those
+   * messages survive the abort and drain into the next turn, so the drain path
+   * owes them the same synthetic tool_result repair a steer gets: the killed
+   * turn may have left `tool_use` blocks with no results. Unlike
+   * `pendingSteerRepair` this does not promote a single head message. An
+   * interrupt has nothing to promote, so the drain batches the queue the way it
+   * would after any other turn. Cleared after repair.
+   * @internal
+   */
+  pendingInterruptRepair = false;
   /**
    * When true, side-effect tools must prompt even if a trust/allow rule
    * would auto-allow. Set by non-interactive callers (e.g. non-guardian

package/src/runtime/AGENTS.md

@@ -12,6 +12,8 @@ The single HTTP send endpoint is `POST /v1/messages`. Key behaviors:
 
 Do NOT add new send endpoints. All message ingress should go through `POST /v1/messages` (HTTP).
 
+**A user interrupt ends the turn, not the queue.** `POST /v1/conversations/:id/cancel` (Stop / Esc, and the CLI's cancel signal file) aborts the turn in flight; anything the same user queued behind it survives and runs on that turn's drain, because the aborted loop reaches its `finally`, which calls `kickDrainQueue` like any other turn end. `abortConversation` discards the queue only for abort kinds where the conversation itself is going away (dispose, eviction, voice supersession, subagent teardown), and every discarded row gets `message_queued_deleted` alongside `generation_cancelled`. Two invariants to keep: an unconditional `queue.clear()` emits no per-row terminal event, so clients keep rendering a queued row whose cancel/steer buttons are dead (DELETE 404s, steer reports `not_processing`) and whose message is silently lost on the next reload; and a teardown must discard even when the processing flag already reads idle, since a turn that cleared the flag can still be unwinding through its awaited turn-boundary commit with a `kickDrainQueue` ahead of it.
+
 ### Channel inbound honors "queue if busy" via defer-until-idle
 
 Channel inbound turns (Slack/Telegram/etc. — `processChannelMessageInBackground`) obey the same "process when the current turn completes" contract, but they do **not** route through the conversation's queue. A channel turn delivers its reply back through the provider callback URL (streaming session + `finalizeEventDelivery` + processed/delivery bookkeeping); the queue drain fans replies onto the SSE hub only and performs none of that. So a channel turn that arrives while the conversation is mid-turn is **deferred until the processing lock frees** (`withChannelTurnAdmission` in `routes/inbound-stages/channel-turn-admission.ts`: per-conversation single-flight for FIFO ordering + event-driven `waitForIdle`), then run with its delivery orchestration intact.

package/src/runtime/routes/__tests__/inference-profiles-routes.test.ts

@@ -277,6 +277,10 @@ describe("collectProfileReferences", () => {
         memoryExtraction: { profile: "my-fast" },
         recall: { profile: "other" },
       },
+      defaultProfileOverrides: {
+        balanced: "my-fast",
+        "cost-optimized": "other",
+      },
       profiles: {
         "my-fast": { source: "user", provider: "anthropic" },
         "my-mix": {
@@ -290,6 +294,7 @@ describe("collectProfileReferences", () => {
         "llm.activeProfile",
         "llm.advisorProfile",
         "llm.callSites.memoryExtraction",
+        "llm.defaultProfileOverrides.balanced",
         "llm.profiles.my-mix.mix",
       ].sort(),
     );

package/src/runtime/routes/inference-profiles-routes.ts

@@ -296,7 +296,8 @@ function fragmentFromBody(
 
 /**
  * Enumerate every live reference to profile `name` in the raw `llm` config
- * block: `activeProfile`, `advisorProfile`, each `callSites.<id>.profile`, and
+ * block: `activeProfile`, `advisorProfile`, each `callSites.<id>.profile`,
+ * each `defaultProfileOverrides.<tier>`, and
  * every mix arm (`profiles.<mix>.mix[].profile`). Deleting a profile while any
  * of these point at it would leave a dangling reference that `LLMSchema`'s
  * superRefine rejects on the next load — silently resetting the user's chat
@@ -324,6 +325,14 @@ export function collectProfileReferences(
       }
     }
   }
+  const tierOverrides = asPlainObject(llm.defaultProfileOverrides);
+  if (tierOverrides) {
+    for (const [tier, target] of Object.entries(tierOverrides)) {
+      if (target === name) {
+        refs.push(`llm.defaultProfileOverrides.${tier}`);
+      }
+    }
+  }
   const profiles = asPlainObject(llm.profiles);
   if (profiles) {
     for (const [profileName, profileEntry] of Object.entries(profiles)) {
@@ -741,7 +750,7 @@ export const ROUTES: RouteDefinition[] = [
       "404": { description: "Profile not found" },
       "409": {
         description:
-          "Profile is still referenced by activeProfile, advisorProfile, a call site, or a mix arm",
+          "Profile is still referenced by activeProfile, advisorProfile, a call site, a default-tier override, or a mix arm",
       },
     },
     handler: handleDeleteProfile,

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

@@ -756,8 +756,14 @@ export const ROUTES: RouteDefinition[] = [
     }),
     responseBody: z.object({
       success: z.boolean(),
-      type: z.string(),
-      name: z.string(),
+      type: z.string().optional(),
+      name: z.string().optional(),
+      error: z
+        .string()
+        .optional()
+        .describe(
+          "Why the secret was not stored (e.g. provider-side API key validation failed). Present only when success is false.",
+        ),
     }),
     handler: handleAddSecret,
   },

package/src/util/abort-reasons.ts

@@ -46,6 +46,22 @@ export function createAbortReason(
   };
 }
 
+/**
+ * True when the abort came from a person stopping the turn they are watching
+ * (the Stop button, Esc, or the CLI's cancel signal file) rather than from the
+ * conversation going away or another subsystem seizing it.
+ *
+ * The distinction matters for the message queue. A user interrupt ends the
+ * turn in flight; it says nothing about the messages the same user queued
+ * behind it, so those survive the abort and run on the interrupted turn's
+ * drain. Every other kind (dispose, eviction, voice supersession, subagent
+ * teardown) is the conversation or its owner disappearing, where a queued
+ * message has nothing left to run on and is discarded.
+ */
+export function isUserInterruptAbort(reason: AbortReason | undefined): boolean {
+  return reason?.kind === "user_cancel" || reason?.kind === "signal_cancel";
+}
+
 export function isAbortReason(value: unknown): value is AbortReason {
   if (typeof value !== "object" || value === null) {
     return false;