@vellumai/assistant 0.10.0 → 0.10.1-staging.1

package/src/config/seed-inference-profiles.ts

@@ -11,6 +11,7 @@ import type { ModelIntent } from "../providers/types.js";
 import { credentialKey } from "../security/credential-key.js";
 import { getLogger } from "../util/logger.js";
 import { loadRawConfig, saveRawConfig } from "./loader.js";
+import { isDispatchableProfile } from "./profile-dispatchability.js";
 import {
   DEFAULT_CONTEXT_WINDOW_MAX_INPUT_TOKENS,
   type ProfileEntry,
@@ -41,12 +42,12 @@ type ManagedProfileTemplate = Omit<
  * (`preserveProfileNames`) take precedence when present.
  */
 const MANAGED_PROFILE_TEMPLATES: Record<string, ManagedProfileTemplate> = {
-  // Served by MiniMax M3 on Fireworks via managed platform inference: a strong
+  // Served by MiniMax M3 on Together AI via managed platform inference: a strong
   // open model at a lower price point than the managed Anthropic route.
   balanced: {
     intent: "balanced",
-    provider: "fireworks",
-    connectionName: "fireworks-managed",
+    provider: "together",
+    connectionName: "together-managed",
     source: "managed",
     label: "Balanced",
     description: "Good balance of quality, cost, and speed",
@@ -56,12 +57,28 @@ const MANAGED_PROFILE_TEMPLATES: Record<string, ManagedProfileTemplate> = {
     contextWindow: { maxInputTokens: DEFAULT_CONTEXT_WINDOW_MAX_INPUT_TOKENS },
     topP: 0.95,
   },
+  // Served by GLM 5.2 on Fireworks via managed platform inference: a leading
+  // open model. `model` is pinned explicitly rather than resolved via the
+  // `quality-optimized` intent (which still maps to Anthropic Opus for the
+  // `frontier` profile below).
   "quality-optimized": {
+    model: "accounts/fireworks/models/glm-5p2",
+    provider: "fireworks",
+    connectionName: "fireworks-managed",
+    source: "managed",
+    label: "Quality",
+    description: "High-quality results with a leading open model (GLM 5.2)",
+    maxTokens: 32000,
+    effort: "high",
+    thinking: { enabled: true, streamThinking: true },
+    contextWindow: { maxInputTokens: DEFAULT_CONTEXT_WINDOW_MAX_INPUT_TOKENS },
+  },
+  frontier: {
     intent: "quality-optimized",
     provider: "anthropic",
     connectionName: "anthropic-managed",
     source: "managed",
-    label: "Quality",
+    label: "Frontier",
     description: "Best results with the most capable model",
     maxTokens: 32000,
     effort: "high",
@@ -131,14 +148,6 @@ const USER_PROFILE_TEMPLATES: Record<string, ManagedProfileTemplate> = {
   },
 };
 
-/**
- * The "auto" profile key. When active, the daemon injects the
- * `switch_inference_profile` tool and lets the model self-select a profile
- * per query. No provider/model — the resolver falls through to the call-site
- * default (balanced or custom-balanced for BYOK).
- */
-export const AUTO_PROFILE_KEY = "auto";
-
 export const OS_BETA_PROFILE_KEY = "os-beta";
 export const OS_BETA_FEATURE_FLAG_KEY = "os-beta";
 
@@ -170,9 +179,19 @@ export const OS_BETA_PROFILE_TEMPLATE: ManagedProfileTemplate = {
 export const MANAGED_PROFILE_NAMES = new Set([
   ...Object.keys(MANAGED_PROFILE_TEMPLATES),
   OS_BETA_PROFILE_KEY,
-  AUTO_PROFILE_KEY,
 ]);
 
+// Managed names introduced after profile-ownership metadata existed, so any
+// pre-existing same-named entry must have been user-created. The seed loop
+// protects these from being clobbered: a user may already own a profile under
+// such a name (the settings UI saves custom profiles without a `source`), so an
+// entry that isn't explicitly `source: "managed"` is treated as theirs. The
+// original canonical names (`balanced`/`quality-optimized`/`cost-optimized`)
+// predate ownership metadata — migration 052 seeded them source-less — so they
+// are NOT listed here and always reseed, even when source is absent.
+const NEWLY_RESERVED_MANAGED_NAMES = new Set(["frontier"]);
+const MIX_MIN_ARMS = 2;
+
 export type SeedInferenceProfilesOptions = {
   /**
    * Profile names supplied by the platform/default overlay for this startup.
@@ -289,6 +308,21 @@ export function seedInferenceProfiles(
     if (preservedProfileNames.has(name)) continue;
 
     const previous = readObject(profiles[name]);
+    // Never clobber a custom profile that happens to share a *newly reserved*
+    // managed name (e.g. `frontier`): reseeding would change its provider/model
+    // and mark it managed. Treat anything not explicitly `source: "managed"` as
+    // the user's, since the settings UI saves custom profiles without a `source`
+    // and the source backfill below skips managed names. The original canonical
+    // names are excluded from this guard — they may be source-less *managed*
+    // entries from migration 052, so they must keep reseeding to receive
+    // template updates (see NEWLY_RESERVED_MANAGED_NAMES).
+    if (
+      NEWLY_RESERVED_MANAGED_NAMES.has(name) &&
+      previous &&
+      previous.source !== "managed"
+    ) {
+      continue;
+    }
     const effectiveTemplate: ManagedProfileTemplate = isByokMode
       ? { ...template, label: `${template.label} (Managed)` }
       : template;
@@ -334,25 +368,6 @@ export function seedInferenceProfiles(
     profiles[name] = next as ProfileEntry;
   }
 
-  // 1b. Auto profile — a metadata-only profile with no provider/model. When
-  //     the user selects "Auto", the resolver falls through to the call-site
-  //     default (balanced or custom-balanced), and the agent loop injects the
-  //     switch_inference_profile tool so the model can self-select per query.
-  if (!preservedProfileNames.has(AUTO_PROFILE_KEY)) {
-    const previousAuto = readObject(profiles[AUTO_PROFILE_KEY]);
-    const autoEntry: Record<string, unknown> = {
-      source: "managed",
-      label: "Auto",
-      description:
-        "Automatically routes each query to the best profile — fast for simple questions, capable for complex ones",
-    };
-    if (previousAuto) {
-      if ("label" in previousAuto) autoEntry.label = previousAuto.label;
-      if ("status" in previousAuto) autoEntry.status = previousAuto.status;
-    }
-    profiles[AUTO_PROFILE_KEY] = autoEntry as ProfileEntry;
-  }
-
   // 2. User profiles — only at hatch time for off-platform installations.
   let userConnectionName: string | undefined;
   if (options.isHatch && !isPlatform) {
@@ -394,6 +409,8 @@ export function seedInferenceProfiles(
     }
   }
 
+  pruneNonDispatchableProfiles(llm, profiles);
+
   // Active profile resolution.
   const requestedActiveProfile = readString(llm.activeProfile);
   const requestedActiveEntry =
@@ -414,26 +431,26 @@ export function seedInferenceProfiles(
   }
 
   // Advisor profile: default to the strongest managed profile when unset, so
-  // the advisor consults `quality-optimized` out of the box. Guarded on
-  // existence so it never names a missing profile (superRefine rejects that);
-  // off-platform/BYOK installs can repoint it at one of their own profiles.
-  if (
-    readString(llm.advisorProfile) === undefined &&
-    readObject(profiles["quality-optimized"]) !== null
-  ) {
-    llm.advisorProfile = "quality-optimized";
+  // the advisor consults `frontier` (Anthropic Opus) out of the box, falling
+  // back to `quality-optimized` if `frontier` is unavailable. The `frontier`
+  // arm requires managed ownership: the seed loop above leaves a user-owned
+  // profile named `frontier` in place, and pointing the advisor at that would
+  // consult an arbitrary user model. Guarded on existence so it never names a
+  // missing profile (superRefine rejects that); off-platform/BYOK installs can
+  // repoint it at one of their own profiles.
+  if (readString(llm.advisorProfile) === undefined) {
+    if (readObject(profiles["frontier"])?.source === "managed") {
+      llm.advisorProfile = "frontier";
+    } else if (readObject(profiles["quality-optimized"]) !== null) {
+      llm.advisorProfile = "quality-optimized";
+    }
   }
 
   // Profile ordering — ensure all seeded profiles appear in the order array.
-  // "auto" is prepended so it appears first in the picker.
   const profileOrder = Array.isArray(llm.profileOrder)
     ? (llm.profileOrder as string[])
     : [];
   const orderSet = new Set(profileOrder);
-  if (!orderSet.has(AUTO_PROFILE_KEY)) {
-    profileOrder.unshift(AUTO_PROFILE_KEY);
-    orderSet.add(AUTO_PROFILE_KEY);
-  }
   for (const name of Object.keys(MANAGED_PROFILE_TEMPLATES)) {
     if (!orderSet.has(name)) {
       profileOrder.push(name);
@@ -490,6 +507,77 @@ export function readObject(value: unknown): Record<string, unknown> | null {
     : null;
 }
 
+function pruneNonDispatchableProfiles(
+  llm: Record<string, unknown>,
+  profiles: Record<string, Record<string, unknown>>,
+): void {
+  const removed = new Set<string>();
+  for (const [name, profile] of Object.entries(profiles)) {
+    if (!isDispatchableProfile(profile)) {
+      delete profiles[name];
+      removed.add(name);
+    }
+  }
+  pruneRemovedProfileReferences(llm, profiles, removed);
+}
+
+function pruneRemovedProfileReferences(
+  llm: Record<string, unknown>,
+  profiles: Record<string, Record<string, unknown>>,
+  removed: Set<string>,
+): void {
+  if (removed.size === 0) return;
+
+  let cascading = true;
+  while (cascading) {
+    cascading = false;
+    for (const [name, profile] of Object.entries(profiles)) {
+      if (removed.has(name)) continue;
+      if (!Array.isArray(profile.mix)) continue;
+      const arms = profile.mix as unknown[];
+      const kept = arms.filter((arm) => {
+        const armProfile = readObject(arm)?.profile;
+        return typeof armProfile !== "string" || !removed.has(armProfile);
+      });
+      if (kept.length === arms.length) continue;
+      if (kept.length >= MIX_MIN_ARMS) {
+        profile.mix = kept;
+      } else {
+        delete profiles[name];
+        removed.add(name);
+      }
+      cascading = true;
+    }
+  }
+
+  if (Array.isArray(llm.profileOrder)) {
+    llm.profileOrder = (llm.profileOrder as unknown[]).filter(
+      (name) => typeof name !== "string" || !removed.has(name),
+    );
+  }
+
+  if (
+    typeof llm.advisorProfile === "string" &&
+    removed.has(llm.advisorProfile)
+  ) {
+    delete llm.advisorProfile;
+  }
+
+  const callSites = readObject(llm.callSites);
+  if (callSites) {
+    for (const entry of Object.values(callSites)) {
+      const site = readObject(entry);
+      if (
+        site &&
+        typeof site.profile === "string" &&
+        removed.has(site.profile)
+      ) {
+        delete site.profile;
+      }
+    }
+  }
+}
+
 function readString(value: unknown): string | undefined {
   return typeof value === "string" && value.length > 0 ? value : undefined;
 }

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

@@ -193,7 +193,19 @@ function disableProfile(
     typeof llm.advisorProfile === "string" &&
     removed.has(llm.advisorProfile)
   ) {
-    if (readObject(profiles["quality-optimized"]) !== null) {
+    // Repoint the advisor at the managed Frontier profile (the strongest).
+    // `frontier` is seeded unconditionally every boot, so target it even if it
+    // has not been materialized yet this startup — this reconcile can run before
+    // the seeder in the boot sequence, and the later seeder won't rewrite an
+    // already-set `advisorProfile`. The exception is a user-owned profile named
+    // `frontier`: that is not ours to route to, so fall back to the
+    // always-managed Quality profile, then clear the pointer as a last resort.
+    const frontierEntry = readObject(profiles["frontier"]);
+    const frontierIsUserOwned =
+      frontierEntry !== null && frontierEntry.source !== "managed";
+    if (!frontierIsUserOwned) {
+      llm.advisorProfile = "frontier";
+    } else if (readObject(profiles["quality-optimized"]) !== null) {
       llm.advisorProfile = "quality-optimized";
     } else {
       delete llm.advisorProfile;

package/src/contacts/contact-store.ts

@@ -184,6 +184,27 @@ export function getContact(id: string): ContactWithChannels | null {
 /** @deprecated Use {@link getContact} directly. */
 export const getContactInternal = getContact;
 
+/** INFO-only contact fields, joined locally by contact ID. */
+export interface ContactInfo {
+  notes: string | null;
+  interactionCount: number;
+}
+
+/**
+ * Look up a contact's INFO fields (notes, interaction count) by ID.
+ *
+ * Carries no ACL state (status/policy/verification) — those are owned by the
+ * gateway-stamped trust verdict. Returns null when the contact does not exist.
+ */
+export function findContactInfoById(contactId: string): ContactInfo | null {
+  const contact = getContact(contactId);
+  if (!contact) return null;
+  return {
+    notes: contact.notes,
+    interactionCount: contact.interactionCount,
+  };
+}
+
 /**
  * Look up a single contact channel by its primary key.
  * Returns the parsed channel row, or null if it does not exist.

package/src/contacts/member-status.ts

@@ -0,0 +1,9 @@
+import type { ChannelStatus } from "./types.js";
+
+/** Map ChannelStatus to the API-facing member status (excludes "unverified"). */
+export function channelStatusToMemberStatus(
+  status: ChannelStatus,
+): Exclude<ChannelStatus, "unverified"> {
+  if (status === "unverified") return "pending";
+  return status;
+}

package/src/credential-health/credential-health-service.ts

@@ -24,6 +24,7 @@ import {
   type OAuthConnectionRow,
   type OAuthProviderRow,
 } from "../oauth/oauth-store.js";
+import { scopeDifference } from "../oauth/scope-utils.js";
 import {
   TokenExpiredError,
   withValidToken,
@@ -77,11 +78,6 @@ function safeJsonParse<T>(raw: string | null | undefined, fallback: T): T {
   }
 }
 
-function scopeDifference(required: string[], granted: string[]): string[] {
-  const grantedSet = new Set(granted);
-  return required.filter((s) => !grantedSet.has(s));
-}
-
 // ── Liveness ping ─────────────────────────────────────────────────────
 
 /** @internal Exposed for test injection. */

package/src/daemon/__tests__/conversation-tool-setup.test.ts

@@ -47,6 +47,20 @@ mock.module("../../runtime/assistant-event-hub.js", () => ({
   broadcastMessage: () => {},
 }));
 
+// Control the advisor profile gate to verify the advisor tool is wired to it.
+// The gate's own config semantics (default-on, active-profile fallback) are
+// covered by advisor-gate.test.ts; here we only assert the wiring and the
+// profile argument isToolActiveForContext passes through.
+let advisorGateResult = true;
+const advisorGateProfiles: (string | null)[] = [];
+
+mock.module("../../plugins/defaults/advisor/advisor-gate.js", () => ({
+  advisorEnabledForProfile: (profile: string | null) => {
+    advisorGateProfiles.push(profile);
+    return advisorGateResult;
+  },
+}));
+
 // Dynamic imports after mock.module calls so the stubs take effect
 // before the modules under test are loaded.
 const { HOST_TOOL_NAMES, HOST_TOOL_TO_CAPABILITY, isToolActiveForContext } =
@@ -597,6 +611,36 @@ describe("isToolActiveForContext — ask_question macOS gating", () => {
   });
 });
 
+describe("isToolActiveForContext — advisor profile gate", () => {
+  beforeEach(() => {
+    advisorGateResult = true;
+    advisorGateProfiles.length = 0;
+  });
+
+  test("advisor is active when the profile enables it", () => {
+    advisorGateResult = true;
+    expect(isToolActiveForContext("advisor", makeCtx())).toBe(true);
+  });
+
+  test("advisor is NOT active when the profile disables it", () => {
+    advisorGateResult = false;
+    expect(isToolActiveForContext("advisor", makeCtx())).toBe(false);
+  });
+
+  test("consults the gate with the per-turn override profile", () => {
+    isToolActiveForContext(
+      "advisor",
+      makeCtx({ currentTurnOverrideProfile: "cost-optimized" }),
+    );
+    expect(advisorGateProfiles).toEqual(["cost-optimized"]);
+  });
+
+  test("consults the gate with null when no per-turn override is set", () => {
+    isToolActiveForContext("advisor", makeCtx());
+    expect(advisorGateProfiles).toEqual([null]);
+  });
+});
+
 describe("HOST_TOOL_NAMES derivation", () => {
   test("HOST_TOOL_NAMES is derived from HOST_TOOL_TO_CAPABILITY", () => {
     // Sanity check: every tool in the names set has a capability mapping.

package/src/daemon/app-source-watcher.ts

@@ -11,11 +11,9 @@
 
 import { existsSync, type FSWatcher, watch } from "node:fs";
 
-import {
-  getAppsDir,
-  resolveAppIdByDirName,
-} from "../memory/app-store.js";
+import { getAppsDir, resolveAppIdByDirName } from "../memory/app-store.js";
 import { DebouncerMap } from "../util/debounce.js";
+import { attachFsWatcherErrorHandler } from "../util/fs-watcher-error.js";
 import { getLogger } from "../util/logger.js";
 
 const log = getLogger("app-source-watcher");
@@ -51,8 +49,10 @@ function resolveAppIdFromRelPath(relPath: string): string | null {
 
   // Skip non-source directories (include bare directory names for fs.watch events)
   if (
-    innerPath === "records" || innerPath.startsWith("records/") ||
-    innerPath === "dist" || innerPath.startsWith("dist/")
+    innerPath === "records" ||
+    innerPath.startsWith("records/") ||
+    innerPath === "dist" ||
+    innerPath.startsWith("dist/")
   ) {
     return null;
   }
@@ -89,7 +89,9 @@ export class AppSourceWatcher {
     try {
       appsDir = getAppsDir();
     } catch {
-      log.warn("Could not resolve apps directory; app source watching disabled");
+      log.warn(
+        "Could not resolve apps directory; app source watching disabled",
+      );
       return;
     }
 
@@ -102,19 +104,30 @@ export class AppSourceWatcher {
     if (!onChange) return;
 
     try {
-      this.watcher = watch(appsDir, { recursive: true }, (_eventType, filename) => {
-        if (!filename) return;
-
-        const appId = resolveAppIdFromRelPath(filename);
-        if (!appId) return;
-
-        this.debouncer.schedule(`app:${appId}`, () => {
-          onChange(appId);
-        });
-      });
+      this.watcher = watch(
+        appsDir,
+        { recursive: true },
+        (_eventType, filename) => {
+          if (!filename) return;
+
+          const appId = resolveAppIdFromRelPath(filename);
+          if (!appId) return;
+
+          this.debouncer.schedule(`app:${appId}`, () => {
+            onChange(appId);
+          });
+        },
+      );
+      // Recursive watches over app trees (incl. node_modules) can exhaust the
+      // inotify watch limit and emit ENOSPC asynchronously. Without an 'error'
+      // listener that unhandled emitter error crashes the daemon.
+      attachFsWatcherErrorHandler(this.watcher, log, appsDir);
       log.info("App source watcher started");
     } catch (err) {
-      log.warn({ err }, "Failed to watch apps directory; source watching disabled");
+      log.warn(
+        { err },
+        "Failed to watch apps directory; source watching disabled",
+      );
     }
   }
 

package/src/daemon/assistant-attachments.ts

@@ -256,6 +256,88 @@ export function parseDirectives(text: string): DirectiveParseResult {
   };
 }
 
+// ---------------------------------------------------------------------------
+// vellum:// markdown link extraction
+// ---------------------------------------------------------------------------
+
+/**
+ * Match markdown links with `vellum://workspace/` or `vellum://host/` URLs.
+ *
+ * Captures:
+ *   [1] = link text (filename)
+ *   [2] = scheme authority: "workspace" or "host"
+ *   [3] = path after the authority
+ *
+ * The link text is NOT stripped from the assistant's message — unlike
+ * `<vellum-attachment />` tags, the markdown link is valid user-facing
+ * content that renders as a clickable download link.
+ */
+const VELLUM_LINK_RE = /\[([^\]]+)\]\(vellum:\/\/(workspace|host)(\/[^)]*)\)/g;
+
+interface VellumLinkExtractResult {
+  directiveRequests: DirectiveRequest[];
+  parseWarnings: string[];
+}
+
+/**
+ * Extract `[text](vellum://workspace/path)` and `[text](vellum://host/path)`
+ * markdown links from assistant text and return corresponding directive
+ * requests. The text is NOT modified — the links remain as rendered markdown.
+ */
+export function extractVellumLinks(text: string): VellumLinkExtractResult {
+  const directiveRequests: DirectiveRequest[] = [];
+  const parseWarnings: string[] = [];
+
+  let m: RegExpExecArray | null;
+  while ((m = VELLUM_LINK_RE.exec(text)) != null) {
+    const linkText = m[1]!;
+    const authority = m[2]!;
+    const rawPath = m[3]!;
+
+    if (authority === "workspace") {
+      // Strip the leading "/" to get a workspace-relative path
+      const path = rawPath.startsWith("/") ? rawPath.slice(1) : rawPath;
+      if (!path) {
+        parseWarnings.push(
+          `Ignored vellum://workspace link "${linkText}": empty path.`,
+        );
+        continue;
+      }
+      directiveRequests.push({
+        source: "sandbox",
+        path,
+        filename: linkText || undefined,
+        mimeType: undefined,
+      });
+    } else {
+      // host: rawPath is already absolute (starts with /)
+      if (!rawPath || rawPath === "/") {
+        parseWarnings.push(
+          `Ignored vellum://host link "${linkText}": empty path.`,
+        );
+        continue;
+      }
+      directiveRequests.push({
+        source: "host",
+        path: rawPath,
+        filename: linkText || undefined,
+        mimeType: undefined,
+      });
+    }
+  }
+
+  return { directiveRequests, parseWarnings };
+}
+
+/**
+ * Replace `[text](vellum://...)` markdown links with their link text.
+ * Used to sanitize text before channel delivery (Slack, Telegram, etc.)
+ * where the `vellum://` scheme has no meaning.
+ */
+export function stripVellumLinks(text: string): string {
+  return text.replace(VELLUM_LINK_RE, "$1");
+}
+
 /**
  * Drain streamed assistant text while stripping only valid, complete
  * self-closing `<vellum-attachment ... />` directives.
@@ -707,10 +789,18 @@ export function cleanAssistantContent(content: readonly unknown[]): {
       const b = block as Record<string, unknown>;
       if (b.type !== "text") return block;
       const text = b.text as string;
-      // Only run the directive parser when the text actually contains a
-      // potential tag. This avoids unintentional whitespace normalisation
-      // (parseDirectives trims and collapses blank lines) on plain messages.
-      if (!text.includes("<vellum-attachment")) return block;
+
+      // Extract vellum:// markdown links (non-destructive — links stay in text)
+      if (text.includes("vellum://")) {
+        const linkResult = extractVellumLinks(text);
+        directives.push(...linkResult.directiveRequests);
+        warnings.push(...linkResult.parseWarnings);
+      }
+
+      // Strip legacy <vellum-attachment /> tags from the text
+      if (!text.includes("<vellum-attachment")) {
+        return block;
+      }
       const result = parseDirectives(text);
       directives.push(...result.directiveRequests);
       warnings.push(...result.parseWarnings);

package/src/daemon/conversation-agent-loop-handlers.ts

@@ -2435,6 +2435,9 @@ export async function dispatchAgentEvent(
           );
         }
         break;
+      case "system_prompt_changed":
+        deps.ctx.systemPrompt = event.systemPrompt;
+        break;
     }
   } catch (err) {
     log.error(