@vellumai/assistant 0.11.0 → 0.11.1-staging.2

package/src/persistence/steps.ts

@@ -462,6 +462,11 @@ import { migrateScheduleSkillScriptHandoff } from "./migrations/351-schedule-ski
 import { migrateDropScheduleSkillScriptHandoff } from "./migrations/352-drop-schedule-skill-script-handoff.js";
 import { migrateAddLlmUsageConversationType } from "./migrations/353-add-llm-usage-conversation-type.js";
 import { migrateBackfillAppConversationLineage } from "./migrations/354-backfill-app-conversation-lineage.js";
+import { migrateAddScheduleGroupId } from "./migrations/355-add-schedule-group-id.js";
+import { migrateAddSubagentParentToolUseId } from "./migrations/356-add-subagent-parent-tool-use-id.js";
+import { migrateMoveMemorySegmentsToMemoryDb } from "./migrations/357-move-memory-segments-to-memory-db.js";
+import { migrateMoveMemoryEmbeddingsToMemoryDb } from "./migrations/358-move-memory-embeddings-to-memory-db.js";
+import { migrateMoveMemorySummariesToMemoryDb } from "./migrations/359-move-memory-summaries-to-memory-db.js";
 import type { MigrationStep } from "./migrations/run-migrations.js";
 
 export const migrationSteps: MigrationStep[] = [
@@ -1481,4 +1486,59 @@ export const migrationSteps: MigrationStep[] = [
   migrateDropScheduleSkillScriptHandoff,
   migrateAddLlmUsageConversationType,
   migrateBackfillAppConversationLineage,
+  migrateAddScheduleGroupId,
+  migrateAddSubagentParentToolUseId,
+  {
+    name: "migrateMoveMemorySegmentsToMemoryDb",
+    run: migrateMoveMemorySegmentsToMemoryDb,
+    // Gate on every migration that creates, alters, indexes, or reads
+    // memory_segments on main: the FTS triggers, FTS backfill, and index
+    // creation each fail against the dropped table if they run after the move.
+    // migrateDeletePrivateConversations relies on the message-delete cascade to
+    // clear private segments, so it must land before the move; the runtime
+    // conversation-delete path is handled separately by adding memory_segments
+    // to CONVERSATION_KEYED_MEMORY_TABLES.
+    dependsOn: [
+      "migrateCoreTables",
+      "migrateMemoryFtsBackfill",
+      "migrateMemorySegmentsIndexes",
+      "createWatchersAndLogsTables",
+      "addCoreColumns",
+      "createCoreIndexes",
+      "migrateDeletePrivateConversations",
+    ],
+  },
+  {
+    name: "migrateMoveMemoryEmbeddingsToMemoryDb",
+    run: migrateMoveMemoryEmbeddingsToMemoryDb,
+    // Gate on every migration that creates, alters, or writes rows in
+    // memory_embeddings on main so the move never drains a table another
+    // migration still expects there.
+    dependsOn: [
+      "migrateCoreTables",
+      "migrateEmbeddingVectorBlob",
+      "migrateEmbeddingsNullableVectorJson",
+      "addCoreColumns",
+      "createCoreIndexes",
+      "migrateDropSimplifiedMemory",
+      "migrateDeletePrivateConversations",
+      "migrateSweepOrphanedGraphNodeVectors",
+    ],
+  },
+  {
+    name: "migrateMoveMemorySummariesToMemoryDb",
+    run: migrateMoveMemorySummariesToMemoryDb,
+    // Gate on every migration that creates, alters, indexes, or clears
+    // memory_summaries on main. migrateDeletePrivateConversations deletes
+    // private-scoped summaries by scope_id directly (a real column, though the
+    // Drizzle schema does not map it), so it must land before the move.
+    dependsOn: [
+      "migrateCoreTables",
+      "migrateRemainingTableIndexes",
+      "addCoreColumns",
+      "createCoreIndexes",
+      "migrateDeletePrivateConversations",
+      "migrateMemorySummariesScopeUpdatedIndex",
+    ],
+  },
 ];

package/src/persistence/subagent-store.ts

@@ -4,9 +4,14 @@
  *
  * This module owns only the durable row shape and raw SQL. The mapping to and
  * from the manager's `SubagentState` lives in `SubagentManager`, keeping this
- * layer decoupled from the subagent domain types.
+ * layer decoupled from the subagent domain types. The one domain function it
+ * does reach for is `normalizeSubagentLabel`: label lookups have to fold
+ * exactly the way the manager's in-memory index folds, and SQLite has no
+ * equivalent (`lower()` is ASCII-only), so the comparison runs in JS against
+ * the single shared normalizer rather than a SQL predicate that can drift.
  */
 
+import { normalizeSubagentLabel } from "../subagent/types.js";
 import { rawAll, rawGet, rawRun } from "./raw-query.js";
 
 /** A durable subagent lifecycle record (camelCase mirror of the row). */
@@ -20,6 +25,11 @@ export interface SubagentRecord {
   isFork: boolean;
   /** Tri-state: null when the spawner left it unset. */
   sendResultToUser: boolean | null;
+  /**
+   * Tool-use id of the call that spawned this subagent; null when the spawn
+   * had no anchoring tool call.
+   */
+  parentToolUseId: string | null;
   status: string;
   error: string | null;
   createdAt: number;
@@ -30,6 +40,16 @@ export interface SubagentRecord {
   estimatedCost: number;
 }
 
+/**
+ * A record plus its SQLite `rowid`, which is insertion order and therefore
+ * spawn order (a row is written when the subagent is spawned). Breaks a
+ * same-millisecond `created_at` tie deterministically. Kept off
+ * `SubagentRecord` so it cannot ride a record spread onto a wire response.
+ */
+export interface RehydratableSubagentRecord extends SubagentRecord {
+  spawnSeq: number;
+}
+
 /** Raw row shape (snake_case, SQLite stores booleans as 0/1). */
 interface SubagentRow {
   id: string;
@@ -40,6 +60,7 @@ interface SubagentRow {
   role: string;
   is_fork: number;
   send_result_to_user: number | null;
+  parent_tool_use_id: string | null;
   status: string;
   error: string | null;
   created_at: number;
@@ -50,6 +71,10 @@ interface SubagentRow {
   estimated_cost: number;
 }
 
+interface RehydratableSubagentRow extends SubagentRow {
+  spawn_seq: number;
+}
+
 function rowToRecord(r: SubagentRow): SubagentRecord {
   return {
     id: r.id,
@@ -61,6 +86,7 @@ function rowToRecord(r: SubagentRow): SubagentRecord {
     isFork: r.is_fork === 1,
     sendResultToUser:
       r.send_result_to_user == null ? null : r.send_result_to_user === 1,
+    parentToolUseId: r.parent_tool_use_id,
     status: r.status,
     error: r.error,
     createdAt: r.created_at,
@@ -72,6 +98,12 @@ function rowToRecord(r: SubagentRow): SubagentRecord {
   };
 }
 
+function rowToRehydratableRecord(
+  r: RehydratableSubagentRow,
+): RehydratableSubagentRecord {
+  return { ...rowToRecord(r), spawnSeq: r.spawn_seq };
+}
+
 /**
  * Insert or update a subagent record. Called on spawn and on every status
  * transition; the conflict clause refreshes the mutable lifecycle fields while
@@ -82,9 +114,10 @@ export function upsertSubagentRecord(rec: SubagentRecord): void {
     "subagent:upsertRecord",
     `INSERT INTO subagents (
        id, parent_conversation_id, conversation_id, label, objective, role,
-       is_fork, send_result_to_user, status, error, created_at, started_at,
-       completed_at, input_tokens, output_tokens, estimated_cost
-     ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+       is_fork, send_result_to_user, parent_tool_use_id, status, error,
+       created_at, started_at, completed_at, input_tokens, output_tokens,
+       estimated_cost
+     ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
      ON CONFLICT(id) DO UPDATE SET
        status = excluded.status,
        error = excluded.error,
@@ -101,6 +134,7 @@ export function upsertSubagentRecord(rec: SubagentRecord): void {
     rec.role,
     rec.isFork ? 1 : 0,
     rec.sendResultToUser == null ? null : rec.sendResultToUser ? 1 : 0,
+    rec.parentToolUseId,
     rec.status,
     rec.error,
     rec.createdAt,
@@ -112,13 +146,51 @@ export function upsertSubagentRecord(rec: SubagentRecord): void {
   );
 }
 
-/** Load every persisted subagent record. Used once at startup to rehydrate. */
+/** Load every persisted subagent record, unbounded. */
 export function loadAllSubagentRecords(): SubagentRecord[] {
   return rawAll<SubagentRow>("subagent:loadAll", `SELECT * FROM subagents`).map(
     rowToRecord,
   );
 }
 
+/**
+ * The subagent records a restart should rebuild in memory. Rows live as long as
+ * their parent conversation, so the table is unbounded history while a
+ * rehydrated entry only serves the current session, and the result is bounded:
+ * every row whose status is NOT in `bound.terminalStatuses` is returned (an
+ * unsettled row has to be settled at any age), plus the `bound.maxTerminal`
+ * most recently finished terminal rows. Recency is `completed_at` falling back
+ * to `created_at`, since a row settled at rehydration records no completion
+ * time.
+ *
+ * The terminal status set is supplied by the caller so this layer stays
+ * decoupled from the subagent domain's status enum.
+ *
+ * Each record carries its `spawnSeq`: the branches are unordered relative to
+ * each other, so the caller needs a spawn key that does not depend on the order
+ * rows arrive in.
+ */
+export function loadRehydratableSubagentRecords(bound: {
+  terminalStatuses: readonly string[];
+  maxTerminal: number;
+}): RehydratableSubagentRecord[] {
+  const placeholders = bound.terminalStatuses.map(() => "?").join(", ");
+  return rawAll<RehydratableSubagentRow>(
+    "subagent:loadRehydratable",
+    `SELECT *, rowid AS spawn_seq FROM subagents WHERE status NOT IN (${placeholders})
+     UNION ALL
+     SELECT * FROM (
+       SELECT *, rowid AS spawn_seq FROM subagents
+         WHERE status IN (${placeholders})
+         ORDER BY COALESCE(completed_at, created_at) DESC
+         LIMIT ?
+     )`,
+    ...bound.terminalStatuses,
+    ...bound.terminalStatuses,
+    bound.maxTerminal,
+  ).map(rowToRehydratableRecord);
+}
+
 /**
  * Look up the subagent record whose child conversation is `conversationId`,
  * or `undefined` when the conversation is not a subagent. `conversation_id` is
@@ -137,7 +209,114 @@ export function getSubagentRecordByConversationId(
   return row ? rowToRecord(row) : undefined;
 }
 
-/** Delete a subagent record once the manager is fully done with it. */
-export function deleteSubagentRecord(id: string): void {
-  rawRun("subagent:deleteRecord", `DELETE FROM subagents WHERE id = ?`, id);
+/**
+ * Look up a subagent record by its own id. This is the durable fallback for
+ * subagents the live SubagentManager no longer holds, evicted by the TTL sweep,
+ * not yet rehydrated after a restart, or past the rehydration bound.
+ */
+export function getSubagentRecordById(id: string): SubagentRecord | undefined {
+  const row = rawGet<SubagentRow>(
+    "subagent:getById",
+    `SELECT * FROM subagents WHERE id = ?`,
+    id,
+  );
+  return row ? rowToRecord(row) : undefined;
+}
+
+/**
+ * The most recent subagent a parent spawned under `normalizedLabel`, or
+ * `undefined` when it never used that label. The durable counterpart of the
+ * manager's label index, for a subagent the manager no longer holds. The
+ * caller supplies the label already normalized, by `normalizeSubagentLabel`,
+ * which is what the rows are folded with here too.
+ *
+ * The match runs in JS, not SQL: SQLite's `lower()` folds ASCII only, so a SQL
+ * predicate silently misses a label such as `ÉTAPE` that the Unicode-aware
+ * normalizer matches, and the durable path would then disagree with the
+ * in-memory index. Only the parent's own rows are read, served by
+ * `idx_subagents_parent_conversation_id` and few per conversation.
+ *
+ * Ordered by spawn order, matching the in-memory index, which the manager moves
+ * to the newest subagent to claim the label whatever order the runs finish in.
+ * Ordering by completion instead would resolve two concurrent same-label runs
+ * to the older one whenever the newer finished first. `rowid` breaks a
+ * same-millisecond `created_at` tie by insertion order, which is spawn order.
+ */
+export function getSubagentRecordByLabel(
+  parentConversationId: string,
+  normalizedLabel: string,
+): SubagentRecord | undefined {
+  const rows = rawAll<SubagentRow>(
+    "subagent:getByLabel",
+    `SELECT * FROM subagents
+       WHERE parent_conversation_id = ?
+       ORDER BY created_at DESC, rowid DESC`,
+    parentConversationId,
+  );
+  const row = rows.find(
+    (r) => normalizeSubagentLabel(r.label) === normalizedLabel,
+  );
+  return row ? rowToRecord(row) : undefined;
+}
+
+/**
+ * Subagent records spawned under `parentConversationId`. Durable rows outlive
+ * the manager's in-memory metadata, the TTL sweep evicts terminal entries with
+ * `keepRecord: true`, so this is the only way to enumerate a parent's
+ * subagents that finished long enough ago to have been swept.
+ *
+ * Rows live as long as the parent conversation, so a long-lived chat
+ * accumulates them without limit and the result is bounded: every row whose
+ * status is NOT in `bound.terminalStatuses` is returned (an unsettled row
+ * matters at any age), plus the `bound.maxTerminal` most recently finished
+ * terminal rows. Recency is `completed_at` falling back to `created_at`, since
+ * a row settled at rehydration records no completion time.
+ *
+ * The terminal status set is supplied by the caller so this layer stays
+ * decoupled from the subagent domain's status enum.
+ */
+export function getSubagentRecordsByParent(
+  parentConversationId: string,
+  bound: { terminalStatuses: readonly string[]; maxTerminal: number },
+): SubagentRecord[] {
+  const placeholders = bound.terminalStatuses.map(() => "?").join(", ");
+  return rawAll<SubagentRow>(
+    "subagent:getByParent",
+    `SELECT * FROM subagents
+       WHERE parent_conversation_id = ? AND status NOT IN (${placeholders})
+     UNION ALL
+     SELECT * FROM (
+       SELECT * FROM subagents
+         WHERE parent_conversation_id = ? AND status IN (${placeholders})
+         ORDER BY COALESCE(completed_at, created_at) DESC
+         LIMIT ?
+     )`,
+    parentConversationId,
+    ...bound.terminalStatuses,
+    parentConversationId,
+    ...bound.terminalStatuses,
+    bound.maxTerminal,
+  ).map(rowToRecord);
+}
+
+/**
+ * Delete every subagent record spawned under `parentConversationId`. A row
+ * lives as long as its parent conversation, and the TTL sweep drops a child's
+ * in-memory entry while keeping the row, so deleting by id alone strands the
+ * swept children when the parent goes away. Served by
+ * `idx_subagents_parent_conversation_id`.
+ */
+export function deleteSubagentRecordsByParent(
+  parentConversationId: string,
+): void {
+  rawRun(
+    "subagent:deleteRecordsByParent",
+    `DELETE FROM subagents WHERE parent_conversation_id = ?`,
+    parentConversationId,
+  );
+}
+
+/** Delete every subagent record. For clear-all, when all chat data goes away. */
+export function deleteAllSubagentRecords(): void {
+  rawRun("subagent:deleteAllRecords", `DELETE FROM subagents`);
 }

package/src/persistence/usage-buckets.ts

@@ -102,7 +102,9 @@ function getLocalParts(epochMillis: number, tz: string): LocalParts {
  */
 function parseShortOffset(value: string): number {
   const match = value.match(/GMT([+-])(\d{1,2})(?::(\d{2}))?/);
-  if (!match) return 0;
+  if (!match) {
+    return 0;
+  }
   const sign = match[1] === "-" ? -1 : 1;
   const hours = Number(match[2]);
   const minutes = match[3] ? Number(match[3]) : 0;
@@ -175,8 +177,12 @@ function alignToLocalHourStart(epochMillis: number, tz: string): number {
   let minute = 0;
   let second = 0;
   for (const part of parts) {
-    if (part.type === "minute") minute = Number(part.value);
-    if (part.type === "second") second = Number(part.value);
+    if (part.type === "minute") {
+      minute = Number(part.value);
+    }
+    if (part.type === "second") {
+      second = Number(part.value);
+    }
   }
   return epochMillis - (minute * 60 + second) * 1000;
 }

package/src/persistence/usage-grouped-buckets.ts

@@ -53,7 +53,9 @@ export function stableUsageSeriesGroupKey(
   groupBy: GroupByDimension,
   groupKey: string | null,
 ): string {
-  if (groupKey !== null) return `${VALUE_GROUP_PREFIX}${groupKey}`;
+  if (groupKey !== null) {
+    return `${VALUE_GROUP_PREFIX}${groupKey}`;
+  }
   return `${NULL_GROUP_PREFIX}${groupBy}`;
 }
 
@@ -94,7 +96,9 @@ export function bucketGroupedUsageEvents(
 
   for (const row of rows) {
     const [bucket] = bucketEvents([row], range, tz);
-    if (!bucket) continue;
+    if (!bucket) {
+      continue;
+    }
 
     let groupedBucket = buckets.get(bucket.bucketId);
     if (!groupedBucket) {

package/src/platform/feature-gate.ts

@@ -1,6 +1,8 @@
 import { getDisablePlatform, getIsPlatform } from "../config/env-registry.js";
 
 export function arePlatformFeaturesEnabled(): boolean {
-  if (getIsPlatform()) return true;
+  if (getIsPlatform()) {
+    return true;
+  }
   return !getDisablePlatform();
 }

package/src/platform/sync-identity.ts

@@ -49,7 +49,9 @@ let pending: Promise<void> = Promise.resolve();
  * - The name is empty or unchanged since the last request.
  */
 export function syncIdentityNameToPlatform(name: string): void {
-  if (!name || name === lastRequestedName) return;
+  if (!name || name === lastRequestedName) {
+    return;
+  }
 
   lastRequestedName = name;
 
@@ -85,10 +87,14 @@ export function syncWorkspaceIdentityToPlatform(): void {
 async function doSync(name: string, requestSeq: number): Promise<void> {
   try {
     // A newer call has already been enqueued — skip this stale request.
-    if (requestSeq !== seq) return;
+    if (requestSeq !== seq) {
+      return;
+    }
 
     // Re-check after awaiting the previous request in the chain.
-    if (name === lastSyncedName) return;
+    if (name === lastSyncedName) {
+      return;
+    }
 
     const client = await VellumPlatformClient.create();
     if (!client) {

package/src/playbooks/playbook-compiler.ts

@@ -54,7 +54,9 @@ export function compilePlaybooks(): CompiledPlaybooks {
   for (const row of rows) {
     // Content format: "Playbook: <trigger>\n<json statement>"
     const newlineIdx = row.content.indexOf("\n");
-    if (newlineIdx === -1) continue;
+    if (newlineIdx === -1) {
+      continue;
+    }
     const statement = row.content.slice(newlineIdx + 1);
     const playbook = parsePlaybookStatement(statement);
     if (playbook) {

package/src/plugin-api/index.ts

@@ -238,14 +238,47 @@ export { getWorkspaceDir } from "../util/platform.js";
 // to embed CLI command capabilities without importing the CLI action graph.
 // Pure data — iterate the fields directly.
 export { CLI_COMMAND_HELP } from "../cli/index.help.js";
-// Embeddings — self-contained operations on the host's shared embedding /
+// Embeddings: self-contained operations on the host's shared embedding /
 // vector-store subsystem. Host-resolved: each reads the live workspace config
 // internally, so plugins hold no config. Async because the facade loads the
 // embed graph lazily on first call.
+//
+// Two families:
+//   • Compute-only (`embed`, `generateSparseEmbedding`): run the workspace
+//     backend and return raw vectors, with no persistence.
+//   • Index (`indexDocument` / `queryIndex` / `getDocument` / `removeDocument`):
+//     a plugin-owned semantic namespace (hybrid dense+sparse search),
+//     automatically scoped to the calling plugin, that never participates in
+//     agent recall. It is a derived cache of the plugin's own source data.
+//   • `embedAndUpsert` remains the legacy write-only host-recall path.
+export type {
+  EmbedResult,
+  IndexDocumentOptions,
+  IndexDocumentResult,
+  IndexedDocument,
+  IndexHit,
+  QueryIndexOptions,
+} from "../persistence/embeddings/plugin-facade.js";
 export {
+  embed,
   embedAndUpsert,
+  generateSparseEmbedding,
+  getDocument,
+  indexDocument,
+  queryIndex,
+  removeDocument,
   selectedBackendSupportsMultimodal,
 } from "../persistence/embeddings/plugin-facade.js";
+// Embedding input/output value shapes shared by the compute and index APIs.
+export type {
+  AudioEmbeddingInput,
+  EmbeddingInput,
+  ImageEmbeddingInput,
+  MultimodalEmbeddingInput,
+  SparseEmbedding,
+  TextEmbeddingInput,
+  VideoEmbeddingInput,
+} from "../persistence/embeddings/embedding-types.js";
 // Graph-node orphan sweep — deletes `graph_node` Qdrant points whose backing
 // `memory_graph_nodes` row is gone (cacheless points the cache-driven sweep
 // cannot see). The memory plugin's `sweep_orphaned_graph_node_points` job

package/src/plugin-api/model-profiles.test.ts

@@ -17,6 +17,7 @@ interface MockProfileEntry {
 let mockProfiles: Record<string, MockProfileEntry> = {};
 let mockActiveProfile: string | undefined;
 let mockProfileOrder: string[] | undefined;
+let mockDefaultProvider: { provider: string } | undefined;
 
 const { getModelProfiles } = await import("./model-profiles.js");
 
@@ -34,6 +35,7 @@ function listProfiles(): ReturnType<typeof getModelProfiles> {
     profiles: mockProfiles,
     activeProfile: mockActiveProfile,
     profileOrder: mockProfileOrder,
+    defaultProvider: mockDefaultProvider,
   };
   return getModelProfiles();
 }
@@ -44,6 +46,7 @@ beforeEach(() => {
   mockProfiles = {};
   mockActiveProfile = undefined;
   mockProfileOrder = undefined;
+  mockDefaultProvider = undefined;
 });
 
 // ─── Tests ──────────────────────────────────────────────────────────────────
@@ -136,6 +139,33 @@ describe("getModelProfiles", () => {
     }
   });
 
+  test("default profile descriptions follow the default provider's column", () => {
+    // The BYOK and vellum columns of the profile matrix carry different
+    // description strings for quality-optimized and cost-optimized; the
+    // listed description must come from the column that actually dispatches.
+    mockDefaultProvider = { provider: "anthropic" };
+
+    const result = listProfiles();
+    expect(result.find((p) => p.key === "quality-optimized")?.description).toBe(
+      "Best results with the most capable model",
+    );
+    expect(result.find((p) => p.key === "cost-optimized")?.description).toBe(
+      "Fastest responses at lower cost",
+    );
+  });
+
+  test("default profile descriptions use the managed column without a default provider", () => {
+    const result = listProfiles();
+    expect(result.find((p) => p.key === "quality-optimized")?.description).toBe(
+      "High-quality results with the most capable model",
+    );
+    // Tier descriptions are intent-only (no model names - LUM-2881), so the
+    // managed and BYOK columns read the same for this tier.
+    expect(result.find((p) => p.key === "cost-optimized")?.description).toBe(
+      "Fastest responses at lower cost",
+    );
+  });
+
   test("marks the active profile with isActive", () => {
     mockProfiles = {
       balanced: { label: "Balanced", provider: "anthropic" },

package/src/plugin-api/model-profiles.ts

@@ -1,4 +1,4 @@
-import { getEffectiveProfiles } from "../config/default-profile-catalog.js";
+import { getEffectiveProfilesForProvider } from "../config/default-profile-catalog.js";
 import { getConfig } from "../config/loader.js";
 import { isDispatchableProfile } from "../config/profile-dispatchability.js";
 import { orderProfileKeys } from "../config/profile-order.js";
@@ -20,12 +20,19 @@ import type { ModelProfileInfo } from "./types.js";
 export function getModelProfiles(): ModelProfileInfo[] {
   const { llm } = getConfig();
   const { activeProfile } = llm;
-  const profiles = getEffectiveProfiles(llm.profiles);
+  const profiles = getEffectiveProfilesForProvider(
+    llm.profiles,
+    llm.defaultProvider ?? null,
+  );
   const result: ModelProfileInfo[] = [];
   for (const key of orderProfileKeys(profiles, llm.profileOrder)) {
     const entry = profiles[key];
-    if (entry == null) continue;
-    if (!isDispatchableProfile(entry)) continue;
+    if (entry == null) {
+      continue;
+    }
+    if (!isDispatchableProfile(entry)) {
+      continue;
+    }
     result.push({
       key,
       label: entry.label ?? key,

package/src/plugin-api/vision-support.test.ts

@@ -14,6 +14,8 @@ interface MockProfileEntry {
 }
 
 let mockProfiles: Record<string, MockProfileEntry> = {};
+let mockDefaultProvider: { provider: string; connectionName?: string } | null =
+  null;
 
 // Real model catalog — don't mock it, the test exercises real catalog lookups.
 const { doesSupportVision } = await import("./vision-support.js");
@@ -40,16 +42,26 @@ function profile(key: string): ModelProfileInfo {
 function applyConfig(): void {
   setConfig("llm", { profiles: {} });
   const config = getConfig() as { llm: unknown };
-  config.llm = { profiles: mockProfiles };
+  config.llm = {
+    profiles: mockProfiles,
+    ...(mockDefaultProvider != null
+      ? { defaultProvider: mockDefaultProvider }
+      : {}),
+  };
 }
 
-function setMockConfig(profiles: Record<string, MockProfileEntry>) {
+function setMockConfig(
+  profiles: Record<string, MockProfileEntry>,
+  defaultProvider?: { provider: string; connectionName?: string },
+) {
   mockProfiles = profiles;
+  mockDefaultProvider = defaultProvider ?? null;
   applyConfig();
 }
 
 beforeEach(() => {
   mockProfiles = {};
+  mockDefaultProvider = null;
   applyConfig();
 });
 
@@ -147,6 +159,57 @@ describe("doesSupportVision", () => {
   });
 });
 
+describe("doesSupportVision with a BYO default provider", () => {
+  test("judges a default profile against the default provider's column model", () => {
+    // Managed/vellum column: balanced → glm-5p2 (text-only, supportsVision:
+    // false). Anthropic column: balanced → claude-sonnet-4-6 (supportsVision:
+    // true). The judged model must be the one the BYO install actually runs.
+    setMockConfig({}, { provider: "anthropic" });
+    expect(doesSupportVision(profile("balanced"))).toBe(true);
+  });
+
+  test("without a default provider, a default profile judges the managed column", () => {
+    // Null-reduction: no defaultProvider resolves balanced through the
+    // vellum column (glm-5p2, text-only).
+    setMockConfig({});
+    expect(doesSupportVision(profile("balanced"))).toBe(false);
+  });
+
+  test("mix arms naming a default profile resolve through the same column", () => {
+    setMockConfig(
+      {
+        "mix-profile": {
+          mix: [
+            { profile: "text-arm", weight: 0.5 },
+            { profile: "balanced", weight: 0.5 },
+          ],
+        },
+        "text-arm": {
+          provider: "fireworks",
+          model: "accounts/fireworks/models/glm-5p2",
+        },
+      },
+      { provider: "anthropic" },
+    );
+    // The "balanced" arm resolves to the anthropic column's vision-capable
+    // model, so the mix can route to vision.
+    expect(doesSupportVision(profile("mix-profile"))).toBe(true);
+  });
+
+  test("a user-owned profile is unaffected by the default provider", () => {
+    setMockConfig(
+      {
+        "custom-text": {
+          provider: "fireworks",
+          model: "accounts/fireworks/models/glm-5p2",
+        },
+      },
+      { provider: "anthropic" },
+    );
+    expect(doesSupportVision(profile("custom-text"))).toBe(false);
+  });
+});
+
 describe("doesSupportVision with a bare string", () => {
   test("returns true for a known vision-capable model id", () => {
     expect(doesSupportVision("claude-opus-4-6")).toBe(true);