@vellumai/assistant 0.6.4 → 0.6.6

package/src/watcher/providers/outlook-calendar.ts

@@ -8,8 +8,6 @@
  * token has expired (410 Gone).
  */
 
-import { OutlookCalendarApiError } from "../../config/bundled-skills/outlook-calendar/calendar-client.js";
-import type { OutlookCalendarEvent } from "../../config/bundled-skills/outlook-calendar/types.js";
 import type { OAuthConnection } from "../../oauth/connection.js";
 import { resolveOAuthConnection } from "../../oauth/connection-resolver.js";
 import { getLogger } from "../../util/logger.js";
@@ -19,6 +17,48 @@ import type {
   WatcherProvider,
 } from "../provider-types.js";
 
+// ---------------------------------------------------------------------------
+// Local types & helpers used by the watcher provider
+// ---------------------------------------------------------------------------
+
+/** Microsoft Graph date+time pair. timeZone may be omitted when dateTime carries an offset. */
+interface OutlookDateTimeZone {
+  dateTime: string;
+  timeZone?: string;
+}
+
+/** A single calendar event from Microsoft Graph (subset used by watcher). */
+interface OutlookCalendarEvent {
+  id: string;
+  subject?: string;
+  bodyPreview?: string;
+  start?: OutlookDateTimeZone;
+  end?: OutlookDateTimeZone;
+  location?: { displayName?: string };
+  attendees?: Array<{
+    emailAddress: { address: string };
+    status?: { response: string };
+  }>;
+  organizer?: { emailAddress: { address: string; name?: string } };
+  isAllDay?: boolean;
+  isCancelled?: boolean;
+  showAs?: string;
+  webLink?: string;
+  createdDateTime?: string;
+  lastModifiedDateTime?: string;
+}
+
+class OutlookCalendarApiError extends Error {
+  constructor(
+    public readonly status: number,
+    public readonly statusText: string,
+    message: string,
+  ) {
+    super(message);
+    this.name = "OutlookCalendarApiError";
+  }
+}
+
 const CREDENTIAL_SERVICE = "outlook";
 const log = getLogger("watcher:outlook-calendar");
 

package/src/workspace/git-service.ts

@@ -939,6 +939,10 @@ export class WorkspaceGitService {
   /**
    * Write a git note to a specific commit.
    * Uses the 'vellum' notes ref to avoid conflicts with default notes.
+   *
+   * Retries once on `index.lock` errors — `git notes add` briefly holds
+   * a ref lock that can collide with concurrent git operations (e.g. a
+   * heartbeat commit racing with fire-and-forget enrichment).
    */
   async writeNote(
     commitHash: string,
@@ -946,10 +950,25 @@ export class WorkspaceGitService {
     signal?: AbortSignal,
   ): Promise<void> {
     await this.mutex.withLock(async () => {
-      await this.execGit(
-        ["notes", "--ref=vellum", "add", "-f", "-m", noteContent, commitHash],
-        { signal },
-      );
+      const args = [
+        "notes",
+        "--ref=vellum",
+        "add",
+        "-f",
+        "-m",
+        noteContent,
+        commitHash,
+      ];
+      try {
+        await this.execGit(args, { signal });
+      } catch (err) {
+        const msg = (err as Error).message ?? "";
+        if (!msg.includes("index.lock") && !msg.includes("Unable to create")) {
+          throw err;
+        }
+        await new Promise((r) => setTimeout(r, 50));
+        await this.execGit(args, { signal });
+      }
     });
   }
 

package/src/workspace/migrations/006-services-config.ts

@@ -1,6 +1,7 @@
 import { existsSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 
+import { providerForImageModelPrefix } from "../../media/types.js";
 import { credentialKey } from "../../security/credential-key.js";
 import {
   getProviderKeyAsync,
@@ -110,10 +111,7 @@ export const servicesConfigMigration: WorkspaceMigration = {
     services["image-generation"] = {
       ...(existingServices["image-generation"] ?? {}),
       mode: "your-own",
-      provider:
-        imageGenModel.startsWith("dall-e") || imageGenModel.startsWith("gpt")
-          ? "openai"
-          : "gemini",
+      provider: providerForImageModelPrefix(imageGenModel),
       model: imageGenModel,
     };
 

package/src/workspace/migrations/022-move-hooks-to-workspace.ts

@@ -43,9 +43,8 @@ export const moveHooksToWorkspaceMigration: WorkspaceMigration = {
     if (!existsSync(oldHooksDir)) return;
 
     // Move hook entries from root to workspace. The old (user) entries take
-    // precedence over anything already at the destination (e.g. template
-    // files written by installTemplates(), which runs before migrations).
-    // We remove the destination first so renameSync succeeds atomically.
+    // precedence over anything already at the destination. We remove the
+    // destination first so renameSync succeeds atomically.
     try {
       const entries = readdirSync(oldHooksDir);
       for (const entry of entries) {

package/src/workspace/migrations/038-unify-llm-callsite-configs.ts

@@ -0,0 +1,516 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+import type { WorkspaceMigration } from "./types.js";
+
+/**
+ * Consolidate scattered LLM-related config keys into the unified `llm` block
+ * introduced in PR 1 of the LLM call-site unification plan.
+ *
+ * What this migration writes (under `llm.*`):
+ *   - `llm.default` — provider/model/maxTokens/effort/speed/thinking/contextWindow
+ *     pulled from `services.inference.{provider,model}` and the legacy
+ *     top-level `maxTokens`/`effort`/`speed`/`thinking`/`contextWindow` keys.
+ *     `temperature` is seeded as `null` because no current config source maps to
+ *     it.
+ *   - `llm.callSites.<id>` — per-call-site overrides derived from the existing
+ *     scattered config (`heartbeat.speed`, `filing.speed`,
+ *     `analysis.modelIntent`/`modelOverride`,
+ *     `memory.summarization.modelIntent`,
+ *     `workspaceGit.commitMessageLLM.{maxTokens,temperature}`,
+ *     `ui.greetingModelIntent`, `notifications.decisionModelIntent` (which
+ *     drives both `notificationDecision` and `preferenceExtraction`),
+ *     `calls.model`).
+ *   - `llm.pricingOverrides` — copied from the top-level `pricingOverrides`.
+ *
+ * What this migration does NOT do:
+ *   - Delete any of the source keys. The legacy keys remain on disk so
+ *     existing readers continue to work. PR 19 of the plan removes them from
+ *     the schema once every call site has been switched over to read through
+ *     the resolver.
+ *
+ * Idempotency:
+ *   - Early-returns when `config.llm.default` is already present, so re-runs
+ *     and runs against an already-migrated workspace are no-ops.
+ *   - Early-returns on missing/malformed `config.json`.
+ *
+ * Rollback (`down`):
+ *   - Reverses the mapping best-effort by extracting `llm.default.*` back to
+ *     top-level + `services.inference`, extracting `llm.callSites.*` back to
+ *     scattered keys, copying `llm.pricingOverrides` back to top-level
+ *     `pricingOverrides`, and finally removing `llm`. After PRs 7-18 land and
+ *     callers stop reading the old keys, rollback fidelity will degrade
+ *     (callers will only see what `down` writes back), which is acceptable
+ *     for a development rollback path.
+ */
+export const unifyLlmCallSiteConfigsMigration: WorkspaceMigration = {
+  id: "038-unify-llm-callsite-configs",
+  description:
+    "Consolidate scattered LLM config keys into unified llm.{default,profiles,callSites} structure",
+  run(workspaceDir: string): void {
+    const configPath = join(workspaceDir, "config.json");
+    if (!existsSync(configPath)) return;
+
+    let config: Record<string, unknown>;
+    try {
+      const raw = JSON.parse(readFileSync(configPath, "utf-8"));
+      if (!raw || typeof raw !== "object" || Array.isArray(raw)) return;
+      config = raw as Record<string, unknown>;
+    } catch {
+      return;
+    }
+
+    // Idempotency: skip only when `llm.default` is present AND no legacy
+    // source key remains on disk. The `&& !hasLegacyData` clause matters
+    // because `AssistantConfigSchema` wires `llm: LLMSchema.default(LLMSchema
+    // .parse({}))`, which makes `loadConfig()` inject a full schema-default
+    // `llm.default` block to disk on first daemon boot under the new schema.
+    // If that boot happened before this migration was added (or before the
+    // daemon binary that includes it landed on the user's machine),
+    // `llm.default` will be present BUT will hold schema defaults rather
+    // than the user's actual `services.inference.{provider, model}` values.
+    // Returning early here would let migration 039 strip the legacy keys
+    // silently, dropping the user's real configuration.
+    const existingLlm = readObject(config.llm);
+    const existingDefault = existingLlm
+      ? readObject(existingLlm.default)
+      : null;
+    const hasLegacyData =
+      hasLegacyLlmDefaultSource(config) || hasLegacyCallSiteSource(config);
+    if (existingDefault !== null && !hasLegacyData) {
+      return;
+    }
+
+    // ── Build llm.default ──────────────────────────────────────────────
+    // Precedence (highest wins): legacy source key → existing `llm.default`
+    // value → migration fallback. Existing values come second so that on a
+    // re-run AFTER legacy keys are stripped, user-set `llm.default.*` values
+    // survive untouched (the early-return above handles the common no-op
+    // path; this ordering covers the partial-state case).
+    const services = readObject(config.services) ?? {};
+    const inference = readObject(services.inference) ?? {};
+
+    const defaultBlock: Record<string, unknown> = {
+      provider:
+        readString(inference.provider) ??
+        readString(config.provider) ??
+        readString(existingDefault?.provider) ??
+        "anthropic",
+      model:
+        readString(inference.model) ??
+        readString(config.model) ??
+        readString(existingDefault?.model) ??
+        "claude-opus-4-6",
+      maxTokens:
+        readPositiveInt(config.maxTokens) ??
+        readPositiveInt(existingDefault?.maxTokens) ??
+        64000,
+      effort:
+        readEnum(config.effort, EFFORT_VALUES) ??
+        readEnum(existingDefault?.effort, EFFORT_VALUES) ??
+        "max",
+      speed:
+        readEnum(config.speed, SPEED_VALUES) ??
+        readEnum(existingDefault?.speed, SPEED_VALUES) ??
+        "standard",
+      // No current legacy key maps to temperature; preserve existing
+      // `llm.default.temperature` if a user set one, else seed null to
+      // match `LLMConfigBase` defaults.
+      temperature:
+        existingDefault && "temperature" in existingDefault
+          ? (existingDefault.temperature as number | null)
+          : null,
+    };
+    const thinking =
+      readObject(config.thinking) ??
+      (existingDefault ? readObject(existingDefault.thinking) : null);
+    if (thinking !== null) {
+      defaultBlock.thinking = thinking;
+    }
+    const contextWindow =
+      readObject(config.contextWindow) ??
+      (existingDefault ? readObject(existingDefault.contextWindow) : null);
+    if (contextWindow !== null) {
+      defaultBlock.contextWindow = contextWindow;
+    }
+
+    // ── Build llm.callSites ────────────────────────────────────────────
+    const callSites: Record<string, Record<string, unknown>> = {};
+
+    const heartbeat = readObject(config.heartbeat);
+    const heartbeatSpeed = heartbeat
+      ? readEnum(heartbeat.speed, SPEED_VALUES)
+      : undefined;
+    if (heartbeatSpeed !== undefined && heartbeatSpeed !== defaultBlock.speed) {
+      callSites.heartbeatAgent = { speed: heartbeatSpeed };
+    }
+
+    const filing = readObject(config.filing);
+    const filingSpeed = filing
+      ? readEnum(filing.speed, SPEED_VALUES)
+      : undefined;
+    if (filingSpeed !== undefined && filingSpeed !== defaultBlock.speed) {
+      callSites.filingAgent = { speed: filingSpeed };
+    }
+
+    const analysis = readObject(config.analysis);
+    if (analysis !== null) {
+      const analysisOverride = readString(analysis.modelOverride);
+      const analysisIntent = readModelIntent(analysis.modelIntent);
+      const analysisCallSite: Record<string, unknown> = {};
+      // `modelOverride` is shaped as `"provider/model"` — explode into the
+      // resolver's separate provider/model fields. If the string lacks a
+      // slash, treat the whole value as the model and inherit the active
+      // provider implicitly via the resolver's default merge.
+      if (analysisOverride !== undefined) {
+        const [providerPart, ...modelParts] = analysisOverride.split("/");
+        if (modelParts.length > 0 && providerPart.length > 0) {
+          analysisCallSite.provider = providerPart;
+          analysisCallSite.model = modelParts.join("/");
+        } else {
+          analysisCallSite.model = analysisOverride;
+        }
+      } else if (analysisIntent !== undefined) {
+        // Resolve intent to provider/model using the same lookup the runtime
+        // uses (mirrors `providers/model-intents.ts` PROVIDER_MODEL_INTENTS).
+        const provider = String(defaultBlock.provider);
+        const resolvedModel = resolveModelIntentForProvider(
+          provider,
+          analysisIntent,
+        );
+        if (resolvedModel !== undefined) {
+          analysisCallSite.model = resolvedModel;
+        }
+      }
+      if (Object.keys(analysisCallSite).length > 0) {
+        callSites.analyzeConversation = analysisCallSite;
+      }
+    }
+
+    const memory = readObject(config.memory);
+    const summarization = memory ? readObject(memory.summarization) : null;
+    const summarizationIntent = summarization
+      ? readModelIntent(summarization.modelIntent)
+      : undefined;
+    if (summarizationIntent !== undefined) {
+      const provider = String(defaultBlock.provider);
+      const resolvedModel = resolveModelIntentForProvider(
+        provider,
+        summarizationIntent,
+      );
+      if (resolvedModel !== undefined) {
+        callSites.conversationSummarization = { model: resolvedModel };
+      }
+    }
+
+    const workspaceGit = readObject(config.workspaceGit);
+    const commitMessageLLM = workspaceGit
+      ? readObject(workspaceGit.commitMessageLLM)
+      : null;
+    if (commitMessageLLM !== null) {
+      const commitOverride: Record<string, unknown> = {};
+      const cmMaxTokens = readPositiveInt(commitMessageLLM.maxTokens);
+      if (cmMaxTokens !== undefined) {
+        commitOverride.maxTokens = cmMaxTokens;
+      }
+      const cmTemperature = readTemperature(commitMessageLLM.temperature);
+      if (cmTemperature !== undefined) {
+        commitOverride.temperature = cmTemperature;
+      }
+      if (Object.keys(commitOverride).length > 0) {
+        callSites.commitMessage = commitOverride;
+      }
+    }
+
+    const ui = readObject(config.ui);
+    const greetingIntent = ui
+      ? readModelIntent(ui.greetingModelIntent)
+      : undefined;
+    if (greetingIntent !== undefined) {
+      const provider = String(defaultBlock.provider);
+      const resolvedModel = resolveModelIntentForProvider(
+        provider,
+        greetingIntent,
+      );
+      if (resolvedModel !== undefined) {
+        callSites.emptyStateGreeting = { model: resolvedModel };
+      }
+    }
+
+    const notifications = readObject(config.notifications);
+    const notificationIntent = notifications
+      ? readModelIntent(notifications.decisionModelIntent)
+      : undefined;
+    if (notificationIntent !== undefined) {
+      const provider = String(defaultBlock.provider);
+      const resolvedModel = resolveModelIntentForProvider(
+        provider,
+        notificationIntent,
+      );
+      if (resolvedModel !== undefined) {
+        // `notifications.decisionModelIntent` drives BOTH the notification
+        // decision engine (`notifications/decision-engine.ts`) AND the
+        // preference extractor (`notifications/preference-extractor.ts`), so
+        // seed both call sites from the same source intent. Confirmed via
+        // grep — those are the only two readers of the legacy key.
+        callSites.notificationDecision = { model: resolvedModel };
+        callSites.preferenceExtraction = { model: resolvedModel };
+      }
+    }
+
+    const calls = readObject(config.calls);
+    const callsModel = calls ? readString(calls.model) : undefined;
+    if (callsModel !== undefined) {
+      callSites.callAgent = { model: callsModel };
+    }
+
+    // ── Build llm block ────────────────────────────────────────────────
+    //
+    // Preserve any pre-existing `llm` subtree. Reaching this point means
+    // `llm.default` was absent (idempotency check at the top), but a user
+    // may still have defined `llm.callSites`, `llm.profiles`, or
+    // `llm.pricingOverrides` directly. Wholesale-replacing `config.llm`
+    // would silently drop those user overrides, so deep-merge instead:
+    //   - `default`: always taken from this migration (we just synthesized
+    //     it from legacy keys).
+    //   - `callSites`: per-key merge, with migration-derived entries
+    //     overwriting pre-existing entries that share the same key.
+    //   - `profiles`: preserved verbatim from existing `llm.profiles`.
+    //   - `pricingOverrides`: prefer the migration-derived value (legacy
+    //     top-level `pricingOverrides`); fall back to existing
+    //     `llm.pricingOverrides` if the legacy key is absent.
+    const llmBlock: Record<string, unknown> = {
+      default: defaultBlock,
+    };
+    const existingProfiles = existingLlm
+      ? readObject(existingLlm.profiles)
+      : null;
+    if (existingProfiles !== null) {
+      llmBlock.profiles = existingProfiles;
+    }
+    const existingCallSites = existingLlm
+      ? readObject(existingLlm.callSites)
+      : null;
+    const mergedCallSites: Record<string, Record<string, unknown>> = {};
+    if (existingCallSites !== null) {
+      for (const [key, value] of Object.entries(existingCallSites)) {
+        const obj = readObject(value);
+        if (obj !== null) {
+          mergedCallSites[key] = obj;
+        }
+      }
+    }
+    for (const [key, value] of Object.entries(callSites)) {
+      mergedCallSites[key] = value;
+    }
+    if (Object.keys(mergedCallSites).length > 0) {
+      llmBlock.callSites = mergedCallSites;
+    }
+    const pricingOverrides = config.pricingOverrides;
+    if (Array.isArray(pricingOverrides)) {
+      llmBlock.pricingOverrides = pricingOverrides;
+    } else if (existingLlm && Array.isArray(existingLlm.pricingOverrides)) {
+      llmBlock.pricingOverrides = existingLlm.pricingOverrides;
+    }
+
+    config.llm = llmBlock;
+
+    writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+  },
+  /**
+   * Documented no-op since PR 19 of the unify-llm-callsites plan.
+   *
+   * The legacy keys that this migration consolidates (`services.inference.
+   * {provider,model}`, top-level `maxTokens`/`effort`/`speed`/`thinking`/
+   * `contextWindow`/`pricingOverrides`, `heartbeat.speed`, `filing.speed`,
+   * `analysis.modelIntent`/`modelOverride`, `memory.summarization.modelIntent`,
+   * `notifications.decisionModelIntent`, `ui.greetingModelIntent`,
+   * `calls.model`, and `workspaceGit.commitMessageLLM.{maxTokens,temperature}`)
+   * were removed from `AssistantConfigSchema` in PR 19. Re-creating them in
+   * `down()` would have no effect on the running daemon (no code reads them
+   * any more), so a rollback that needs to undo this migration must instead
+   * roll back the application binary to a build that predates PR 19.
+   */
+  down(_workspaceDir: string): void {
+    // Forward-only after PR 19. See comment above.
+  },
+};
+
+// ---------------------------------------------------------------------------
+// Helpers — self-contained per workspace migrations AGENTS.md
+// ---------------------------------------------------------------------------
+
+// `xhigh` was added to the runtime enum in main PR #26117 after this
+// migration was authored. Widening the validation set is safe (it can only
+// admit MORE legitimate values, never narrow them) and prevents an `effort:
+// "xhigh"` legacy value from being silently downgraded to "max" during the
+// consolidation below.
+const EFFORT_VALUES = new Set(["low", "medium", "high", "xhigh", "max"]);
+const SPEED_VALUES = new Set(["standard", "fast"]);
+const MODEL_INTENT_VALUES = new Set([
+  "latency-optimized",
+  "quality-optimized",
+  "vision-optimized",
+]);
+
+/**
+ * Mirror of `providers/model-intents.ts:PROVIDER_MODEL_INTENTS` snapshotted at
+ * the time this migration was authored. Migrations are write-once and must be
+ * self-contained — duplicating the table here means the migration's behavior
+ * is frozen against the catalog as it existed when users upgraded across this
+ * boundary, even if the runtime catalog evolves later.
+ */
+const PROVIDER_MODEL_INTENTS_SNAPSHOT: Record<
+  string,
+  Record<string, string>
+> = {
+  anthropic: {
+    "latency-optimized": "claude-haiku-4-5-20251001",
+    "quality-optimized": "claude-opus-4-7",
+    "vision-optimized": "claude-opus-4-6",
+  },
+  openai: {
+    "latency-optimized": "gpt-5.4-nano",
+    "quality-optimized": "gpt-5.4",
+    "vision-optimized": "gpt-5.4",
+  },
+  gemini: {
+    "latency-optimized": "gemini-3-flash",
+    "quality-optimized": "gemini-3-flash",
+    "vision-optimized": "gemini-3-flash",
+  },
+  ollama: {
+    "latency-optimized": "llama3.2",
+    "quality-optimized": "llama3.2",
+    "vision-optimized": "llama3.2",
+  },
+  fireworks: {
+    "latency-optimized": "accounts/fireworks/models/kimi-k2p5",
+    "quality-optimized": "accounts/fireworks/models/kimi-k2p5",
+    "vision-optimized": "accounts/fireworks/models/kimi-k2p5",
+  },
+  openrouter: {
+    "latency-optimized": "anthropic/claude-haiku-4.5",
+    "quality-optimized": "anthropic/claude-opus-4.7",
+    "vision-optimized": "anthropic/claude-opus-4.6",
+  },
+};
+
+function resolveModelIntentForProvider(
+  provider: string,
+  intent: string,
+): string | undefined {
+  return PROVIDER_MODEL_INTENTS_SNAPSHOT[provider]?.[intent];
+}
+
+function readObject(value: unknown): Record<string, unknown> | null {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    return null;
+  }
+  return value as Record<string, unknown>;
+}
+
+function readString(value: unknown): string | undefined {
+  return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+
+function readPositiveInt(value: unknown): number | undefined {
+  return typeof value === "number" && Number.isInteger(value) && value > 0
+    ? value
+    : undefined;
+}
+
+function readEnum<T extends string>(
+  value: unknown,
+  allowed: Set<string>,
+): T | undefined {
+  return typeof value === "string" && allowed.has(value)
+    ? (value as T)
+    : undefined;
+}
+
+function readModelIntent(value: unknown): string | undefined {
+  return typeof value === "string" && MODEL_INTENT_VALUES.has(value)
+    ? value
+    : undefined;
+}
+
+function readTemperature(value: unknown): number | undefined {
+  return typeof value === "number" &&
+    Number.isFinite(value) &&
+    value >= 0 &&
+    value <= 2
+    ? value
+    : undefined;
+}
+
+/**
+ * Returns true if any source key that this migration consolidates into
+ * `llm.default` is still present on disk. The `provider`/`model`/etc. checks
+ * cover the `services.inference` and top-level legacy locations; their
+ * presence proves migration 039 hasn't yet stripped them, which means we
+ * MUST re-process even if `llm.default` already exists (it may have been
+ * injected by `loadConfig()`'s schema-default backfill rather than by a
+ * previous run of this migration).
+ */
+function hasLegacyLlmDefaultSource(config: Record<string, unknown>): boolean {
+  const services = readObject(config.services);
+  const inference = services ? readObject(services.inference) : null;
+  if (
+    inference &&
+    (readString(inference.provider) !== undefined ||
+      readString(inference.model) !== undefined)
+  ) {
+    return true;
+  }
+  for (const key of [
+    "provider",
+    "model",
+    "maxTokens",
+    "effort",
+    "speed",
+    "thinking",
+    "contextWindow",
+    "pricingOverrides",
+  ]) {
+    if (key in config) return true;
+  }
+  return false;
+}
+
+/**
+ * Returns true if any source key that this migration consolidates into
+ * `llm.callSites` is still present on disk. Same idempotency justification
+ * as `hasLegacyLlmDefaultSource`: their presence proves migration 039
+ * hasn't yet stripped them and re-processing is required.
+ */
+function hasLegacyCallSiteSource(config: Record<string, unknown>): boolean {
+  const heartbeat = readObject(config.heartbeat);
+  if (heartbeat && "speed" in heartbeat) return true;
+  const filing = readObject(config.filing);
+  if (filing && "speed" in filing) return true;
+  const analysis = readObject(config.analysis);
+  if (analysis && ("modelIntent" in analysis || "modelOverride" in analysis)) {
+    return true;
+  }
+  const memory = readObject(config.memory);
+  const summarization = memory ? readObject(memory.summarization) : null;
+  if (summarization && "modelIntent" in summarization) return true;
+  const notifications = readObject(config.notifications);
+  if (notifications && "decisionModelIntent" in notifications) return true;
+  const ui = readObject(config.ui);
+  if (ui && "greetingModelIntent" in ui) return true;
+  const calls = readObject(config.calls);
+  if (calls && "model" in calls) return true;
+  const workspaceGit = readObject(config.workspaceGit);
+  const commitMessageLLM = workspaceGit
+    ? readObject(workspaceGit.commitMessageLLM)
+    : null;
+  if (
+    commitMessageLLM &&
+    ("maxTokens" in commitMessageLLM || "temperature" in commitMessageLLM)
+  ) {
+    return true;
+  }
+  return false;
+}