@vellumai/assistant 0.8.2 → 0.8.3

package/src/cli/lib/install-from-github.ts

@@ -286,19 +286,18 @@ async function copyFile(
 
 /**
  * Wraps `fetchFn` with the headers we want to send to GitHub for every
- * request. Honors `GITHUB_TOKEN` when present so users who hit the
- * unauthenticated rate limit can opt into a higher cap.
+ * request. Unauthenticated — the canonical source is a public repo, so
+ * there is nothing for an `Authorization` header to do.
  */
 async function githubFetch(
   url: string,
   accept: string,
   fetchFn: FetchLike,
 ): Promise<Response> {
-  const headers: Record<string, string> = {
-    Accept: accept,
-    "User-Agent": "vellum-assistant-cli",
-  };
-  const token = process.env.GITHUB_TOKEN?.trim();
-  if (token) headers.Authorization = `Bearer ${token}`;
-  return fetchFn(url, { headers });
+  return fetchFn(url, {
+    headers: {
+      Accept: accept,
+      "User-Agent": "vellum-assistant-cli",
+    },
+  });
 }

package/src/cli/lib/search-plugins.ts

@@ -0,0 +1,163 @@
+/**
+ * Search for plugin directories in the canonical GitHub source.
+ *
+ * Lists `vellum-ai/vellum-assistant/experimental/plugins/` at the configured
+ * git ref and filters the directory entries by case-insensitive ECMAScript
+ * regex. A plain query like `"memory"` matches anywhere in the name; anchors
+ * like `"^simple"` work without escaping.
+ *
+ * Designed for direct programmatic use. The CLI command
+ * `assistant plugins search <query>` is a thin wrapper that supplies
+ * production deps (`globalThis.fetch`) and formats the result for the
+ * terminal; downstream callers may supply their own `fetch` (e.g. a
+ * retry-decorated client, or a test fixture).
+ */
+
+import type { FetchLike } from "./install-from-github.js";
+import { DEFAULT_PLUGIN_REF } from "./install-from-github.js";
+
+// Re-export the dep-injection type so callers can grab everything they need
+// from one module rather than reaching into `install-from-github.js`.
+export type { FetchLike } from "./install-from-github.js";
+
+const PLUGIN_SOURCE_OWNER = "vellum-ai";
+const PLUGIN_SOURCE_REPO = "vellum-assistant";
+const PLUGIN_SOURCE_PATH_PREFIX = "experimental/plugins";
+
+/** Entry shape returned by the GitHub Contents API for a directory listing. */
+interface GitHubContentEntry {
+  readonly name: string;
+  readonly path: string;
+  readonly type: "file" | "dir" | "symlink" | "submodule";
+  readonly size: number;
+  readonly download_url: string | null;
+}
+
+/** Options that control the search. */
+export interface SearchPluginsOptions {
+  /**
+   * ECMAScript regex pattern. Matched case-insensitively against directory
+   * names. Empty string matches everything.
+   */
+  readonly query: string;
+  /** Git ref to list from. Defaults to {@link DEFAULT_PLUGIN_REF}. */
+  readonly ref?: string;
+}
+
+/** Dependencies injected by the caller. */
+export interface SearchPluginsDeps {
+  /** HTTP client. Production callers pass `globalThis.fetch.bind(globalThis)`. */
+  readonly fetch: FetchLike;
+}
+
+/** One matching plugin directory. */
+export interface PluginSearchMatch {
+  /** Directory name under `experimental/plugins/`. */
+  readonly name: string;
+  /** Path within the repo (e.g. `experimental/plugins/<name>`). */
+  readonly path: string;
+}
+
+/** Search result envelope. */
+export interface SearchPluginsResult {
+  readonly query: string;
+  readonly ref: string;
+  readonly matches: readonly PluginSearchMatch[];
+}
+
+/** Caller passed a query that doesn't compile as an ECMAScript regex. */
+export class InvalidSearchPatternError extends Error {
+  constructor(pattern: string, cause: unknown) {
+    const detail = cause instanceof Error ? cause.message : String(cause);
+    super(`Invalid regex pattern ${JSON.stringify(pattern)}: ${detail}`);
+    this.name = "InvalidSearchPatternError";
+  }
+}
+
+/**
+ * List directories under `experimental/plugins/` at {@link opts.ref} and
+ * filter by {@link opts.query}.
+ *
+ * Only `type === "dir"` entries are returned — `experimental/plugins/`
+ * follows a convention where each plugin lives in its own directory, so
+ * loose files at the prefix are not plugins.
+ */
+export async function searchPlugins(
+  opts: SearchPluginsOptions,
+  deps: SearchPluginsDeps,
+): Promise<SearchPluginsResult> {
+  const ref = opts.ref ?? DEFAULT_PLUGIN_REF;
+
+  // Compile the matcher up front so an invalid regex fails before we hit
+  // the network — keeps "user typo" cheap to recover from.
+  const matcher = buildMatcher(opts.query);
+
+  const entries = await listDir(PLUGIN_SOURCE_PATH_PREFIX, ref, deps.fetch);
+
+  const matches: PluginSearchMatch[] = [];
+  for (const entry of entries) {
+    if (entry.type !== "dir") continue;
+    if (!matcher(entry.name)) continue;
+    matches.push({ name: entry.name, path: entry.path });
+  }
+  matches.sort((a, b) => a.name.localeCompare(b.name));
+
+  return { query: opts.query, ref, matches };
+}
+
+function buildMatcher(query: string): (name: string) => boolean {
+  let re: RegExp;
+  try {
+    re = new RegExp(query, "i");
+  } catch (err) {
+    throw new InvalidSearchPatternError(query, err);
+  }
+  return (name) => re.test(name);
+}
+
+async function listDir(
+  apiPath: string,
+  ref: string,
+  fetchFn: FetchLike,
+): Promise<readonly GitHubContentEntry[]> {
+  const url =
+    `https://api.github.com/repos/${PLUGIN_SOURCE_OWNER}/${PLUGIN_SOURCE_REPO}` +
+    `/contents/${encodeURIComponent(apiPath).replaceAll("%2F", "/")}` +
+    `?ref=${encodeURIComponent(ref)}`;
+
+  const res = await githubFetch(url, fetchFn);
+  if (!res.ok) {
+    // Unlike `installPlugin`, where 404 on a specific plugin name is a
+    // legitimate "not found" outcome, 404 on the plugins prefix itself
+    // means the canonical source path is gone — surface it as an error
+    // rather than silently returning empty results.
+    throw new Error(
+      `GitHub contents listing failed for ${apiPath} @ ${ref}: HTTP ${res.status}`,
+    );
+  }
+
+  const body = (await res.json()) as unknown;
+  if (!Array.isArray(body)) {
+    // A non-array body for a /contents/<dir> path means the path is a
+    // file, not a directory — treat the prefix as empty rather than crash.
+    return [];
+  }
+  return body as readonly GitHubContentEntry[];
+}
+
+/**
+ * Wraps `fetchFn` with the headers we want to send to GitHub for every
+ * request. Unauthenticated — the canonical source is a public repo, mirroring
+ * `installPlugin` which uses the same envelope.
+ */
+async function githubFetch(
+  url: string,
+  fetchFn: FetchLike,
+): Promise<Response> {
+  return fetchFn(url, {
+    headers: {
+      Accept: "application/vnd.github+json",
+      "User-Agent": "vellum-assistant-cli",
+    },
+  });
+}

package/src/cli/program.ts

@@ -62,6 +62,20 @@ import { log } from "./logger.js";
  */
 export async function buildCliProgram(): Promise<Command> {
   await initFeatureFlagOverrides({ retryBackoffsMs: [], callTimeoutMs: 200 });
+  return buildCliProgramTree();
+}
+
+/**
+ * Synchronously build the CLI program tree without pre-populating the
+ * feature-flag cache. Use this from inside the daemon, where flags are
+ * already initialized — calling `buildCliProgram` from there would round-trip
+ * to the gateway unnecessarily.
+ *
+ * Same shape as `buildCliProgram` minus the async feature-flag init: registers
+ * the full subcommand set (conditionally gated on email / external-plugins
+ * flags via `getConfigReadOnly()`) and installs the workspace-preAction hook.
+ */
+export function buildCliProgramTree(): Command {
   const program = new Command();
 
   program

package/src/config/assistant-feature-flags.ts

@@ -110,20 +110,22 @@ function parseRegistryToDefaults(parsed: unknown): FeatureFlagDefaultsRegistry {
 }
 
 // ---------------------------------------------------------------------------
-// Override loading — reads from gateway IPC socket or local file
+// Override loading — reads from gateway IPC socket
 // ---------------------------------------------------------------------------
 
 /**
- * Module-level cache of feature flag override values. Populated lazily on
- * first access, invalidated by `clearFeatureFlagOverridesCache()`.
+ * Module-level cache of feature flag override values. Populated by
+ * `initFeatureFlagOverrides()` at startup, invalidated by
+ * `clearFeatureFlagOverridesCache()`.
  */
 let cachedOverrides: Record<string, boolean> | null = null;
 
 /**
- * True when `cachedOverrides` was populated by the gateway IPC fetch (or
- * preseeded by a test). False/unset when the cache was populated by the sync
- * file fallback in `loadOverrides()`, which must not prevent a subsequent
- * authoritative gateway fetch from running.
+ * True when `cachedOverrides` was populated by the gateway IPC fetch or
+ * preseeded by a test via `_setOverridesForTesting()`. Guards
+ * `initFeatureFlagOverrides()` from clobbering an existing populated cache
+ * when called a second time (e.g. by a CLI entry point after the daemon
+ * has already initialized).
  */
 let cachedOverridesFromGateway = false;
 
@@ -247,59 +249,30 @@ function loadOverrides(): Record<string, boolean> {
   return cachedOverrides ?? {};
 }
 
-// ---------------------------------------------------------------------------
-// Remote values — platform-pushed flags cached in a local JSON file
-// ---------------------------------------------------------------------------
-
 /**
- * Module-level cache of remote feature flag values. Populated lazily on
- * first access, invalidated by `clearFeatureFlagOverridesCache()`.
- */
-let cachedRemoteValues: Record<string, boolean> | null = null;
-
-/**
- * Load remote values with module-level caching.
+ * Invalidate the cached overrides so the next call to
+ * `isAssistantFeatureFlagEnabled` re-reads from the gateway.
  *
- * Remote values are now always included in the gateway IPC response (merged
- * server-side), so this only returns the injected test cache. In production,
- * remote values flow through the overrides cache.
- */
-function loadRemoteValues(): Record<string, boolean> {
-  return cachedRemoteValues ?? {};
-}
-
-/**
- * Invalidate the cached override and remote values so the next call to
- * `isAssistantFeatureFlagEnabled` re-reads from the source.
- *
- * Called by the config watcher when the feature-flags file changes.
+ * Used by tests between cases to reset module state.
  */
 export function clearFeatureFlagOverridesCache(): void {
   cachedOverrides = null;
   cachedOverridesFromGateway = false;
-  cachedRemoteValues = null;
 }
 
 /**
  * Directly inject override values into the module-level cache.
  *
- * **Test-only** — bypasses file/gateway loading so unit tests can control
- * flag state without writing to disk. Production code should never call this;
- * use `clearFeatureFlagOverridesCache()` instead and let the resolver
- * re-read from the appropriate source.
- *
- * Forces `cachedRemoteValues` to an empty record (not `null`) so the resolver
- * does not fall through to reading `feature-flags-remote.json` from disk. This
- * matters because a developer's local remote-cache file can leak platform-set
- * values into the test environment (e.g. `email-channel: true`), defeating
- * test isolation.
+ * **Test-only** — bypasses the gateway IPC fetch so unit tests can control
+ * flag state without standing up a real gateway. Production code should
+ * never call this; use `clearFeatureFlagOverridesCache()` instead and let
+ * the resolver re-read from the gateway.
  */
 export function _setOverridesForTesting(
   overrides: Record<string, boolean>,
 ): void {
   cachedOverrides = { ...overrides };
   cachedOverridesFromGateway = true;
-  cachedRemoteValues = {};
 }
 
 // ---------------------------------------------------------------------------
@@ -310,9 +283,11 @@ export function _setOverridesForTesting(
  * Resolve whether an assistant feature flag is enabled.
  *
  * Resolution order:
- *   1. Override from gateway IPC socket
- *   2. defaults registry `defaultEnabled`         (for declared assistant-scope keys)
- *   3. `true`                                     (for undeclared keys with no override)
+ *   1. Override from the gateway IPC fetch (includes platform-pushed remote
+ *      values, which the gateway merges server-side: persisted > remote >
+ *      registry)
+ *   2. Registry `defaultEnabled` (for declared assistant-scope keys)
+ *   3. `true` (for undeclared keys with no override)
  */
 export function isAssistantFeatureFlagEnabled(
   key: string,
@@ -322,18 +297,13 @@ export function isAssistantFeatureFlagEnabled(
   const declared = defaults[key];
   const overrides = loadOverrides();
 
-  // 1. Check overrides from gateway / local file
+  // 1. Check overrides from the gateway IPC cache.
   const explicit = overrides[key];
   if (typeof explicit === "boolean") return explicit;
 
-  // 2. Check remote values (platform-pushed, cached locally)
-  const remote = loadRemoteValues();
-  const remoteValue = remote[key];
-  if (typeof remoteValue === "boolean") return remoteValue;
-
-  // 3. For declared keys, use the registry default
+  // 2. For declared keys, use the registry default.
   if (declared) return declared.defaultEnabled;
 
-  // 4. Undeclared keys with no persisted override default to enabled
+  // 3. Undeclared keys with no override default to enabled.
   return true;
 }

package/src/config/bundled-skills/app-builder/SKILL.md

@@ -54,8 +54,114 @@ Each record is a JSON file at `<slug>/records/<uuid>.json` with shape:
 
 All new apps use `formatVersion: 2`: source files live under `src/` and compiled output lives under `dist/`. The build system compiles TSX to JS automatically when `app_refresh` is called.
 
+## Responsive Baseline & Mobile-First Mode
+
+Every app must be responsive across the full width range — phone (~360px) to desktop (~1400px+). The conversation context's `<turn_context>` block carries an `interface:` field. Visual interfaces are `macos`, `ios`, and `web`; the field doesn't toggle responsiveness on or off — it shifts the **design priority**. Non-visual values like `phone` represent voice channels that can't render apps at all and don't need to be considered here.
+
+- **`interface: ios`** (or any future mobile-web / android identifier) — mobile-first build. Design the narrow viewport first and progressively enhance upward at wider widths.
+- **`interface: macos` / `web`** — desktop-first build. Design the larger composition first; the narrow-width fallback must still meet the universal baseline below but doesn't need to feel like a native mobile app.
+- **Field absent or ambiguous** — default to desktop-first unless the user's request itself implies phone use ("for my iPhone home screen", "a tap-tracker I'll use on the go").
+
+### Universal baseline (every build, regardless of interface)
+
+These rules aren't mobile-specific — they're touch / responsive a11y baselines that any user-resizable WebView needs.
+
+**Viewport & safe areas**
+
+- Viewport meta: `<meta name="viewport" content="width=device-width, initial-scale=1, viewport-fit=cover">`. Never set `user-scalable=no` — it blocks accessibility zoom.
+- Pad the root container with `env(safe-area-inset-*)` so content clears the notch / home indicator when the app is opened on a notched device: `padding-top: max(var(--v-spacing-lg), env(safe-area-inset-top))`, mirrored for `-bottom`/`-left`/`-right`. On desktop the env vars resolve to `0` and the `max()` falls through to the design-system value — no-op.
+- Use `100dvh` (dynamic viewport height), not `100vh`, for full-height containers. `100vh` creates a scroll-jump on every mobile browser regardless of build mode.
+
+**Form controls**
+
+- `<input>`, `<textarea>`, `<select>` must be `font-size: 16px` or larger, or iOS Safari will zoom on focus and break the layout. This applies to every build — anyone may open a desktop-built app on their phone.
+- Add `inputmode` to text fields with structured input: `numeric` for integers, `decimal` for amounts, `email`, `tel`, `url`. Add matching `autocomplete` and `autocapitalize` hints where appropriate.
+
+**Touch & hover**
+
+- Interactive elements (buttons, list rows, nav items, toggles, icon buttons) must be ≥44×44pt. `.v-button` already meets this; for custom controls, set `min-height: 44px` explicitly.
+- Gate hover affordances behind `@media (hover: hover)` so they don't stick on touch devices visiting a desktop-built app.
+- Disable text selection on app chrome (headers, nav, buttons) with `user-select: none; -webkit-user-select: none` so long-press doesn't pop the iOS selection menu over interactive elements.
+
+**Layout fluidity**
+
+- Fluid widths only — no fixed-pixel layouts. Use `%`, `fr`, `minmax`, `clamp()` instead of `px` on container widths.
+- Horizontal-scroll tables don't work on narrow screens. At narrow widths, collapse rows into stacked cards with labels and values arranged vertically. (Mobile-first builds can use cards everywhere; desktop-first builds can keep the table at wide widths and switch to cards below a breakpoint.)
+- `vellum.widgets.*` chart containers should be sized in `vw`/`%`, not fixed `px`. Prefer simpler chart types (sparkline, bar) at narrow widths — dense multi-series charts lose detail.
+
+### Mobile-first priorities (`interface: ios` or future mobile identifier)
+
+These are the **design priority differences** that mobile-first builds adopt on top of the universal baseline. They reflect "narrow viewport is the primary experience, wider widths progressively enhance."
+
+**Typography**
+
+- Default body text to `--v-font-size-lg` (17px), not `--v-font-size-base` (14px) — the desktop base is too small to read comfortably on a phone. At wider widths the same 17px reads fine.
+
+**Spacing**
+
+- Bump default vertical rhythm one step (e.g. `--v-spacing-md` → `--v-spacing-lg` between cards and sections) so users can comfortably scroll-stop on each item.
+
+**Layout**
+
+- One column as the **default**, not as a narrow-width fallback. `flex-direction: column` first; opt into a multi-column grid only above a width breakpoint (`@media (min-width: 720px)`). No side rails, no two-pane master/detail, no fixed-width sidebars in the default view.
+- Bottom-anchor the primary action (e.g. "Add", "Save") so the thumb can reach it: `position: sticky; bottom: env(safe-area-inset-bottom)` over the scrolling list. On wider widths you may re-flow it back inline.
+- Replace side modals and popovers with bottom sheets that animate up from the bottom edge.
+
+**Interaction**
+
+- Skip the Tab/Enter/Esc keyboard pattern from "Interaction Standards" as the primary affordance — on mobile, focus comes from taps, submit from the soft keyboard's `return`, dismissal from a swipe down on bottom sheets. Keyboard support is still allowed (external-keyboard users exist on iPad) but isn't the design driver.
+
+### Desktop-first priorities (`interface: macos` / `web`)
+
+The default behaviour the rest of this skill describes — multi-column composition, hover-rich affordances, denser information, side modals, inline primary actions. The universal baseline above is the floor: the narrow-width view must still work and follow the touch / responsive a11y rules, but it doesn't need to feel native to mobile.
+
+Everything else in this skill applies unchanged.
+
 ## Workflow
 
+### 0. Preflight — Pin to a high-quality model
+
+App building is design-heavy judgment work — color palettes, layout decisions, component architecture, micro-interactions. A stronger model produces meaningfully better apps: more creative visual directions, cleaner component boundaries, fewer generic patterns. Before building, check whether the conversation is already pinned to the quality profile:
+
+```
+assistant inference session list
+```
+
+If no session is active, check the current default profile:
+
+```
+assistant config get llm.default.profile
+```
+
+If the profile is already `quality-optimized`, skip the rest of this step and proceed to Step 1.
+
+**If the active profile is `balanced`, `cost-optimized`, or any non-quality profile, you MUST ask the user for permission before switching. Do NOT open an inference session without explicit user confirmation.** Use `assistant ui confirm`:
+
+```
+assistant ui confirm --message "App building works best with a high-quality model — it makes better design decisions, writes cleaner components, and produces more visually polished results. Switch to the quality profile for this build? (You can switch back after.)"
+```
+
+If `assistant ui confirm` isn't available on this binary, ask the user directly in conversation instead. **Either way, wait for the user's answer before proceeding.**
+
+**Only if the user confirms**, open an inference session:
+
+```
+assistant inference session open quality-optimized --ttl 1h
+```
+
+If `quality-optimized` isn't a profile name on this workspace, list the available profiles and open against the highest-quality one:
+
+```
+assistant config get llm.profiles
+assistant inference session open <profile-name> --ttl 1h
+```
+
+The `--ttl 1h` gives comfortable headroom for a typical app build without leaving a forever-pinned session if the close in Step 6 is skipped.
+
+**If the user declines, do not switch profiles.** Proceed with the current profile — the build still works, the model just won't be pinned. Skip the close in Step 6 too.
+
+If `assistant inference session` isn't available on this binary, proceed without it.
+
 ### 1. Gather Requirements
 
 **Default: just build.** When a user says "build me a habit tracker," don't ask what colors they want or how many fields to include. Immediately:
@@ -351,6 +457,16 @@ After making all file changes, call `app_refresh(app_id)` once to compile and re
 
 Apps should have multiple source files under `src/` (`styles.css`, components, helpers, etc.). Import CSS and modules from TSX so esbuild includes them in the compiled output.
 
+### 6. Close the inference session
+
+If you opened an inference session in Step 0, close it now:
+
+```
+assistant inference session close
+```
+
+If you skipped the open in Step 0 (because the user declined, the CLI didn't have the command, or the profile was already quality), skip this step too.
+
 ## Interaction Standards
 
 Every app must meet these baselines:
@@ -359,7 +475,7 @@ Every app must meet these baselines:
 - **Confirmation for destructive actions:** Use `window.vellum.confirm(title, message)` before deleting or resetting. Returns `Promise<boolean>`.
 - **Form validation:** Validate before submit, show errors inline, disable submit during async operations.
 - **Loading states:** Never show a blank screen while data loads. Use skeleton shimmer or spinners.
-- **Keyboard navigation:** `Tab` between elements, `Enter` to submit, `Escape` to close/cancel.
+- **Keyboard navigation:** `Tab` between elements, `Enter` to submit, `Escape` to close/cancel. *(De-prioritised on mobile-first builds — see [Responsive Baseline & Mobile-First Mode](#responsive-baseline--mobile-first-mode).)*
 
 ## Presentation Slide Design
 

package/src/config/bundled-skills/phone-calls/SKILL.md

@@ -33,7 +33,7 @@ Follow the steps below to ensure everything is prepared to make and receive phon
 
 ## Step 1: Twilio Setup
 
-Load the `twilio-setup` skill to determine whether Twilio has been fully configured and set it up if not. This is a prerequisite to all subsequent steps.
+Immediately load the `twilio-setup` skill to begin setup. That skill marks Twilio setup as started before its read-only checks, which gives managed deployments a chance to open the Velay tunnel WebSocket while the user finishes entering credentials and choosing a number. Twilio setup is a prerequisite to all subsequent steps.
 
 ## Step 2: Enable Calls
 

package/src/config/call-site-defaults.ts

@@ -0,0 +1,105 @@
+import { type LLMCallSite } from "./schemas/llm.js";
+
+type CallSiteDefaultConfig = {
+  profile: string;
+  maxTokens?: number;
+  effort?: "none" | "low" | "medium" | "high" | "xhigh" | "max";
+  temperature?: number | null;
+  thinking?: { enabled?: boolean; streamThinking?: boolean };
+  contextWindow?: { maxInputTokens?: number };
+};
+
+export const CALL_SITE_DEFAULTS: Record<LLMCallSite, CallSiteDefaultConfig> = {
+  mainAgent: { profile: "balanced" },
+  subagentSpawn: { profile: "balanced" },
+  compactionAgent: { profile: "balanced" },
+  analyzeConversation: { profile: "balanced" },
+  patternScan: { profile: "balanced" },
+  narrativeRefinement: { profile: "balanced" },
+  callAgent: { profile: "balanced" },
+  proactiveArtifactBuild: { profile: "balanced" },
+  memoryConsolidation: { profile: "balanced" },
+  identityIntro: { profile: "balanced" },
+  emptyStateGreeting: { profile: "balanced" },
+
+  memoryRouter: {
+    profile: "balanced",
+    contextWindow: { maxInputTokens: 1000000 },
+  },
+  recall: {
+    profile: "balanced",
+    maxTokens: 4096,
+    effort: "low",
+    thinking: { enabled: false, streamThinking: false },
+    temperature: 0,
+  },
+  conversationStarters: {
+    profile: "balanced",
+    effort: "low",
+    thinking: { enabled: false },
+  },
+
+  filingAgent: { profile: "cost-optimized" },
+  proactiveArtifactDecision: { profile: "cost-optimized" },
+  memoryExtraction: { profile: "cost-optimized" },
+  memoryRetrieval: { profile: "cost-optimized" },
+  memoryRetrospective: { profile: "cost-optimized" },
+  memoryV2Migration: { profile: "cost-optimized" },
+  memoryV2Sweep: { profile: "cost-optimized" },
+  memoryV2Consolidation: { profile: "balanced" },
+  conversationSummarization: { profile: "cost-optimized" },
+  conversationTitle: { profile: "cost-optimized" },
+  approvalCopy: { profile: "cost-optimized" },
+  approvalConversation: { profile: "cost-optimized" },
+  trustRuleSuggestion: { profile: "cost-optimized" },
+  styleAnalyzer: { profile: "cost-optimized" },
+  meetConsentMonitor: { profile: "cost-optimized" },
+  meetChatOpportunity: { profile: "cost-optimized" },
+  inference: { profile: "cost-optimized" },
+
+  heartbeatAgent: {
+    profile: "cost-optimized",
+  },
+  commitMessage: {
+    profile: "cost-optimized",
+    maxTokens: 120,
+    temperature: 0.2,
+    effort: "low",
+    thinking: { enabled: false },
+  },
+  replySuggestion: {
+    profile: "cost-optimized",
+    effort: "low",
+    thinking: { enabled: false },
+  },
+  guardianQuestionCopy: {
+    profile: "cost-optimized",
+    effort: "low",
+    thinking: { enabled: false },
+  },
+  notificationDecision: {
+    profile: "cost-optimized",
+    effort: "low",
+    thinking: { enabled: false },
+  },
+  preferenceExtraction: {
+    profile: "cost-optimized",
+    effort: "low",
+    thinking: { enabled: false },
+  },
+  interactionClassifier: {
+    profile: "cost-optimized",
+    effort: "low",
+    thinking: { enabled: false },
+  },
+  inviteInstructionGenerator: {
+    profile: "cost-optimized",
+    effort: "low",
+    thinking: { enabled: false },
+  },
+  skillCategoryInference: {
+    profile: "cost-optimized",
+    effort: "low",
+    thinking: { enabled: false },
+  },
+};