@vellumai/assistant 0.8.7 → 0.8.8

package/src/tools/terminal/safe-env.ts

@@ -69,6 +69,15 @@ export const KATA_SAFE_ENV_VARS = [
 export const KATA_INJECTED_ENV_VARS = ["LD_LIBRARY_PATH"] as const;
 
 const KATA_APT_DATA_ROOT = "/data/system";
+const KATA_FAMILY_SANDBOX_RUNTIMES = new Set([
+  "kata",
+  "firecracker",
+  "cloud-hypervisor",
+]);
+
+function isKataFamilyRuntime(runtime: string | undefined): boolean {
+  return runtime != null && KATA_FAMILY_SANDBOX_RUNTIMES.has(runtime);
+}
 
 function kataAptPaths(dataRoot: string): string[] {
   return [
@@ -118,7 +127,7 @@ function appendUniquePathEntries(
 
 export function buildSanitizedEnv(): Record<string, string> {
   const env: Record<string, string> = {};
-  const isKataRuntime = process.env.VELLUM_SANDBOX_RUNTIME === "kata";
+  const isKataRuntime = isKataFamilyRuntime(process.env.VELLUM_SANDBOX_RUNTIME);
   const safeEnvVars = isKataRuntime
     ? [...SAFE_ENV_VARS, ...KATA_SAFE_ENV_VARS]
     : SAFE_ENV_VARS;

package/src/tools/ui-surface/definitions.ts

@@ -105,13 +105,17 @@ export const uiShowTool = {
     'Surface structured data or UI in the conversation. For long-form writing use the document skill. For interactive apps, dashboards, games, calculators, or durable tools, call `skill_load` with `skill: "app-builder"` and use the app-builder workflow; do not use `dynamic_page` as a substitute for a persistent app. App-like `dynamic_page` calls are rejected.\n\n' +
     "Surface types (data shapes):\n" +
     '- card: { title, subtitle?, body, metadata?: [{ label, value }], template?, templateData? }. Templates: "weather_forecast" (native weather widget), "task_progress" (live step tracker - update via ui_update on data.templateData; shape: { title, status: "in_progress"|"completed"|"failed", steps: [{ label, status: "pending"|"in_progress"|"completed"|"failed", detail? }] })\n' +
+    "- copy_block: { text, label?, language? }. Shows copyable text with a visible copy button; use for prompts, commands, paths, or snippets the user should copy.\n" +
+    '- choice: { description?, options: [{ id, title, description?, recommended?, data? }], selectionMode?: "single"|"multiple", commitOnSelect?, submitLabel? }. Single-select choices commit on option click by default. Use for outcome offers and follow-up choices; mark the strongest option with recommended: true.\n' +
+    "- oauth_connect: { providerKey, displayName?, description?, logoUrl? }. Shows a managed OAuth connection CTA in chat; use when the current task needs a managed integration account (Google, Linear, GitHub, etc.) instead of asking the user to visit settings or attempting OAuth through shell/tools. The client supplies the CTA label. Do not include OAuth scopes in the surface; managed providers use the platform's configured scopes.\n" +
     '- table: { columns: [{ id, label }], rows: [{ id, cells: Record<id, string | { text, icon?, iconColor?: "success"|"warning"|"error"|"muted" }>, selectable?, selected? }], selectionMode?: "none"|"single"|"multiple", caption? }\n' +
     '- form: { description?, fields: [{ id, type: "text"|"textarea"|"select"|"toggle"|"number"|"password", label, placeholder?, required?, defaultValue?, options?: [{ label, value }] }], submitLabel? }. Multi-page: { pages: [{ id, title, description?, fields }], pageLabels?: { next?, back?, submit? }, submitLabel? }\n' +
     '- list: { items: [{ id, title, subtitle?, icon?, selected? }], selectionMode: "single"|"multiple"|"none" }\n' +
     "- confirmation: { message, detail?, confirmLabel?, confirmedLabel?, cancelLabel?, destructive? }\n" +
     "- dynamic_page: { html, width?, height?, preview?: { title, subtitle?, description?, icon?, metrics?: [{ label, value }] } }\n" +
     "- file_upload: { prompt, acceptedTypes?, maxFiles? }\n" +
-    "- task_preferences: {} (no data needed — categories are rendered client-side)\n\n" +
+    "- task_preferences: {} (no data needed — categories are rendered client-side)\n" +
+    '- work_result: { eyebrow?, status?: "completed"|"partial"|"failed"|"in_progress", summary?, metrics?: [{ label, value, detail?, tone?: "neutral"|"positive"|"warning"|"negative" }], sections?: [{ id?, title, description?, type?: "items"|"timeline"|"diff"|"artifacts"|"warnings", items?: [{ id?, title, description?, status?, tone?, metadata?: [{ label, value }], href? }], diffs?: [{ label?, before?, after? }] }] }. Shows a structured receipt after real work: what changed, what was skipped, proof points, and next actions. Keep display-only unless explicit follow-up buttons are needed.\n\n' +
     "Proactively show a task_progress card before multi-step or long-running work (web searches, file operations, research). Show it before your first tool call, then update steps as work progresses.",
   category: "ui-surface",
   defaultRiskLevel: RiskLevel.Low,
@@ -124,6 +128,9 @@ export const uiShowTool = {
         type: "string",
         enum: [
           "card",
+          "choice",
+          "copy_block",
+          "oauth_connect",
           "form",
           "list",
           "table",
@@ -131,6 +138,7 @@ export const uiShowTool = {
           "dynamic_page",
           "file_upload",
           "task_preferences",
+          "work_result",
         ],
         description: "The type of surface to display",
       },

package/src/tts/__tests__/provider-catalog-consistency.test.ts

@@ -30,8 +30,10 @@ import {
 interface ClientCatalogProvider {
   id: string;
   displayName: string;
+  subtitle?: string;
+  supportsVoiceSelection?: boolean;
   credentialMode?: string;
-  credentialsGuide?: { url: string };
+  credentialsGuide?: { description: string; url: string; linkLabel: string };
 }
 
 interface ClientCatalog {
@@ -144,6 +146,88 @@ describe("TTS provider catalog / client artifact consistency", () => {
     }
   });
 
+  // -- Display field parity --------------------------------------------------
+
+  test("subtitle matches between assistant catalog and client artifact", () => {
+    const violations: string[] = [];
+    for (const clientEntry of clientCatalog.providers) {
+      try {
+        const assistantEntry = getCatalogProvider(clientEntry.id as any);
+        if (clientEntry.subtitle !== assistantEntry.subtitle) {
+          violations.push(
+            `"${clientEntry.id}": client="${clientEntry.subtitle}" vs assistant="${assistantEntry.subtitle}"`,
+          );
+        }
+      } catch {
+        // Unknown ID — covered by provider ID parity tests above.
+      }
+    }
+    if (violations.length > 0) {
+      expect(violations, "Subtitle mismatch:\n" + violations.join("\n")).toEqual(
+        [],
+      );
+    }
+  });
+
+  test("supportsVoiceSelection matches between assistant catalog and client artifact", () => {
+    const violations: string[] = [];
+    for (const clientEntry of clientCatalog.providers) {
+      try {
+        const assistantEntry = getCatalogProvider(clientEntry.id as any);
+        if (
+          clientEntry.supportsVoiceSelection !==
+          assistantEntry.supportsVoiceSelection
+        ) {
+          violations.push(
+            `"${clientEntry.id}": client=${clientEntry.supportsVoiceSelection} vs assistant=${assistantEntry.supportsVoiceSelection}`,
+          );
+        }
+      } catch {
+        // Unknown ID — covered by provider ID parity tests above.
+      }
+    }
+    if (violations.length > 0) {
+      expect(
+        violations,
+        "supportsVoiceSelection mismatch:\n" + violations.join("\n"),
+      ).toEqual([]);
+    }
+  });
+
+  test("credentialsGuide matches between assistant catalog and client artifact", () => {
+    const violations: string[] = [];
+    for (const clientEntry of clientCatalog.providers) {
+      try {
+        const assistantEntry = getCatalogProvider(clientEntry.id as any);
+        const cg = clientEntry.credentialsGuide;
+        const ag = assistantEntry.credentialsGuide;
+        if (cg && ag) {
+          if (cg.url !== ag.url) {
+            violations.push(`"${clientEntry.id}": credentialsGuide.url mismatch`);
+          }
+          if (cg.description !== ag.description) {
+            violations.push(
+              `"${clientEntry.id}": credentialsGuide.description mismatch`,
+            );
+          }
+          if (cg.linkLabel !== ag.linkLabel) {
+            violations.push(
+              `"${clientEntry.id}": credentialsGuide.linkLabel mismatch`,
+            );
+          }
+        }
+      } catch {
+        // Unknown ID — covered by provider ID parity tests above.
+      }
+    }
+    if (violations.length > 0) {
+      expect(
+        violations,
+        "credentialsGuide mismatch:\n" + violations.join("\n"),
+      ).toEqual([]);
+    }
+  });
+
   // -- Structural sanity ----------------------------------------------------
 
   test("client artifact version is a positive integer", () => {

package/src/tts/provider-catalog.ts

@@ -55,12 +55,21 @@ interface TtsProviderCatalogCapabilities {
   readonly supportedFormats: readonly string[];
 }
 
+/**
+ * Link to a provider's API-key management page, shown in settings UI.
+ */
+interface TtsCredentialsGuide {
+  readonly description: string;
+  readonly url: string;
+  readonly linkLabel: string;
+}
+
 /**
  * A single entry in the TTS provider catalog.
  *
  * Captures everything the system needs to know about a provider at a
  * metadata level — identity, display name, telephony call mode,
- * capabilities, and secret requirements.
+ * capabilities, secret requirements, and client-facing display metadata.
  */
 interface TtsProviderCatalogEntry {
   /** Unique provider identifier matching {@link TtsProviderId}. */
@@ -69,6 +78,18 @@ interface TtsProviderCatalogEntry {
   /** Human-readable name for display in settings UI and logs. */
   readonly displayName: string;
 
+  /** Short description shown beneath the provider name in settings UI. */
+  readonly subtitle: string;
+
+  /** Whether the provider supports user-chosen voice IDs. */
+  readonly supportsVoiceSelection: boolean;
+
+  /** Placeholder text for the API-key input in settings UI. */
+  readonly apiKeyPlaceholder: string;
+
+  /** Link to the provider's API-key management page. */
+  readonly credentialsGuide: TtsCredentialsGuide;
+
   /** How this provider integrates with the telephony call path. */
   readonly callMode: TtsCallMode;
 
@@ -106,6 +127,16 @@ const CATALOG: readonly TtsProviderCatalogEntry[] = [
   {
     id: "elevenlabs",
     displayName: "ElevenLabs",
+    subtitle:
+      "High-quality voice synthesis for conversations and read-aloud. Requires an ElevenLabs API key.",
+    supportsVoiceSelection: true,
+    apiKeyPlaceholder: "sk_…",
+    credentialsGuide: {
+      description:
+        "Sign in to ElevenLabs, go to your Profile, and copy your API key.",
+      url: "https://elevenlabs.io/app/settings/api-keys",
+      linkLabel: "Open ElevenLabs API Keys",
+    },
     callMode: "native-twilio",
     allowNativeFallback: true,
     capabilities: {
@@ -124,6 +155,16 @@ const CATALOG: readonly TtsProviderCatalogEntry[] = [
   {
     id: "fish-audio",
     displayName: "Fish Audio",
+    subtitle:
+      "Natural-sounding voice synthesis with custom voice cloning. Requires a Fish Audio API key and voice reference ID.",
+    supportsVoiceSelection: true,
+    apiKeyPlaceholder: "Enter your Fish Audio API key",
+    credentialsGuide: {
+      description:
+        "Sign in to Fish Audio, navigate to API Keys in your dashboard, and create a new key.",
+      url: "https://fish.audio/app/api-keys/",
+      linkLabel: "Open Fish Audio API Keys",
+    },
     callMode: "synthesized-play",
     allowNativeFallback: true,
     capabilities: {
@@ -142,6 +183,16 @@ const CATALOG: readonly TtsProviderCatalogEntry[] = [
   {
     id: "deepgram",
     displayName: "Deepgram",
+    subtitle:
+      "Fast, accurate text-to-speech synthesis. Uses the same API key as Deepgram speech-to-text.",
+    supportsVoiceSelection: false,
+    apiKeyPlaceholder: "Enter your Deepgram API key",
+    credentialsGuide: {
+      description:
+        "Sign in to Deepgram, navigate to your API Keys page, and create or copy an existing key. This is the same key used for speech-to-text.",
+      url: "https://console.deepgram.com/",
+      linkLabel: "Open Deepgram Console",
+    },
     callMode: "synthesized-play",
     allowNativeFallback: false,
     capabilities: {
@@ -159,6 +210,16 @@ const CATALOG: readonly TtsProviderCatalogEntry[] = [
   {
     id: "xai",
     displayName: "xAI",
+    subtitle:
+      "Text-to-speech from xAI with expressive voices (eve, ara, rex, sal, leo). Requires an xAI API key.",
+    supportsVoiceSelection: false,
+    apiKeyPlaceholder: "Enter your xAI API key",
+    credentialsGuide: {
+      description:
+        "Sign in to the xAI console, navigate to API Keys, and create a new key.",
+      url: "https://console.x.ai/",
+      linkLabel: "Open xAI Console",
+    },
     callMode: "synthesized-play",
     allowNativeFallback: false,
     capabilities: {
@@ -199,6 +260,20 @@ export function listCatalogProviderIds(): TtsProviderId[] {
   return CATALOG.map((entry) => entry.id);
 }
 
+/**
+ * List all catalog providers projected to client-facing display fields only.
+ */
+export function listCatalogProvidersForDisplay() {
+  return CATALOG.map((e) => ({
+    id: e.id,
+    displayName: e.displayName,
+    subtitle: e.subtitle,
+    supportsVoiceSelection: e.supportsVoiceSelection,
+    apiKeyPlaceholder: e.apiKeyPlaceholder,
+    credentialsGuide: e.credentialsGuide,
+  }));
+}
+
 /**
  * Look up a catalog entry by provider ID.
  *

package/src/util/mutex.ts

@@ -0,0 +1,47 @@
+/**
+ * Async mutex for serializing access to a shared resource.
+ *
+ * Callers wait in FIFO order. `withLock(fn)` is the primary API —
+ * it acquires the lock, runs `fn`, and releases the lock when `fn`
+ * settles (even on throw).
+ *
+ * Used by git-service (per-workspace repo operations) and
+ * conversation-title-service (serial LLM calls) to prevent
+ * concurrent access to resources that cannot safely overlap.
+ */
+export class Mutex {
+  private locked = false;
+  private waitQueue: Array<() => void> = [];
+
+  async acquire(): Promise<void> {
+    if (!this.locked) {
+      this.locked = true;
+      return;
+    }
+    await new Promise<void>((resolve) => {
+      this.waitQueue.push(resolve);
+    });
+  }
+
+  release(): void {
+    const next = this.waitQueue.shift();
+    if (next) {
+      next();
+    } else {
+      this.locked = false;
+    }
+  }
+
+  /**
+   * Execute `fn` while holding the lock.
+   * Automatically releases the lock when done, even if `fn` throws.
+   */
+  async withLock<T>(fn: () => Promise<T>): Promise<T> {
+    await this.acquire();
+    try {
+      return await fn();
+    } finally {
+      this.release();
+    }
+  }
+}

package/src/workspace/git-service.ts

@@ -12,6 +12,7 @@ import { promisify } from "node:util";
 
 import { getConfig } from "../config/loader.js";
 import { getLogger } from "../util/logger.js";
+import { Mutex } from "../util/mutex.js";
 import { PromiseGuard } from "../util/promise-guard.js";
 
 const execFileAsync = promisify(execFile);
@@ -119,48 +120,6 @@ interface ExecError extends Error {
   code?: string | number;
 }
 
-/**
- * Simple mutex implementation for per-workspace git operation serialization.
- * Prevents concurrent git operations from corrupting the repository state.
- */
-class Mutex {
-  private locked = false;
-  private waitQueue: Array<() => void> = [];
-
-  async acquire(): Promise<void> {
-    if (!this.locked) {
-      this.locked = true;
-      return;
-    }
-    // Wait for the lock to be released
-    await new Promise<void>((resolve) => {
-      this.waitQueue.push(resolve);
-    });
-  }
-
-  release(): void {
-    const next = this.waitQueue.shift();
-    if (next) {
-      next();
-    } else {
-      this.locked = false;
-    }
-  }
-
-  /**
-   * Execute a function while holding the lock.
-   * Automatically releases the lock when done, even if the function throws.
-   */
-  async withLock<T>(fn: () => Promise<T>): Promise<T> {
-    await this.acquire();
-    try {
-      return await fn();
-    } finally {
-      this.release();
-    }
-  }
-}
-
 interface GitCommitMetadata {
   /** Optional metadata to include in the commit message or as git notes */
   [key: string]: unknown;

package/src/workspace/migrations/095-bump-heartbeat-interval-30m-to-60m.ts

@@ -0,0 +1,51 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+import type { WorkspaceMigration } from "./types.js";
+
+const THIRTY_MINUTES_MS = 30 * 60 * 1000;
+const SIXTY_MINUTES_MS = 60 * 60 * 1000;
+
+/**
+ * Bump persisted heartbeat default from 30 minutes to 60 minutes.
+ *
+ * Migration 065 moved legacy 3h/6h defaults to 30 minutes. The schema default
+ * has since been raised to 60 minutes, but existing users whose config.json
+ * already has 1800000 persisted won't pick up the new default. This migration
+ * idempotently updates those configs.
+ */
+export const bumpHeartbeatInterval30mTo60mMigration: WorkspaceMigration = {
+  id: "095-bump-heartbeat-interval-30m-to-60m",
+  description:
+    "Bump persisted heartbeat.intervalMs from 30 minutes to 60 minutes",
+  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;
+    }
+
+    const heartbeat = config.heartbeat;
+    if (!heartbeat || typeof heartbeat !== "object" || Array.isArray(heartbeat))
+      return;
+
+    const heartbeatConfig = heartbeat as Record<string, unknown>;
+    const intervalMs = heartbeatConfig.intervalMs;
+    if (typeof intervalMs !== "number" || intervalMs !== THIRTY_MINUTES_MS) {
+      return;
+    }
+
+    heartbeatConfig.intervalMs = SIXTY_MINUTES_MS;
+    writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+  },
+  down(_workspaceDir: string): void {
+    // Forward-only: cannot distinguish users who explicitly chose 60 minutes
+    // from those migrated by this migration.
+  },
+};

package/src/workspace/migrations/096-reduce-quality-profile-effort.ts

@@ -0,0 +1,72 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+import type { WorkspaceMigration } from "./types.js";
+
+// Reduce effort from "max" to "high" on the quality-optimized profile.
+//
+// With adaptive thinking enabled, the effort parameter acts as a nudge for
+// how much thinking the model does. "max" means "always think with no
+// constraints on thinking depth", which defeats adaptive thinking's ability
+// to skip or minimize thinking for simple queries. "high" (the API default)
+// means "almost always thinks, deep reasoning on complex tasks" — letting
+// adaptive thinking decide when full-depth reasoning is actually needed.
+//
+// This migration patches both managed and user quality-optimized profiles
+// that still have effort: "max". It only downgrades "max" → "high"; any
+// other effort value is preserved.
+
+const TARGET_PROFILES = ["quality-optimized", "custom-quality-optimized"];
+
+export const reduceQualityProfileEffortMigration: WorkspaceMigration = {
+  id: "096-reduce-quality-profile-effort",
+  description:
+    'Reduce effort from "max" to "high" on quality-optimized profiles to let adaptive thinking work',
+  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;
+    }
+
+    const llm = readObject(config.llm);
+    if (llm === null) return;
+
+    const profiles = readObject(llm.profiles);
+    if (profiles === null) return;
+
+    let changed = false;
+
+    for (const name of TARGET_PROFILES) {
+      const profile = readObject(profiles[name]);
+      if (profile === null) continue;
+      if (profile.effort !== "max") continue;
+
+      profile.effort = "high";
+      profiles[name] = profile;
+      changed = true;
+    }
+
+    if (changed) {
+      llm.profiles = profiles;
+      config.llm = llm;
+      writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+    }
+  },
+  down(_workspaceDir: string): void {
+    // Forward-only.
+  },
+};
+
+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>;
+}

package/src/workspace/migrations/097-enable-adaptive-thinking-managed-profiles.ts

@@ -0,0 +1,93 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+import type { WorkspaceMigration } from "./types.js";
+
+// Enable adaptive thinking on the managed "balanced" and "quality-optimized"
+// profiles for existing platform instances.
+//
+// The assistant-side seed defaults (MANAGED_PROFILE_TEMPLATES in
+// seed-inference-profiles.ts) already ship thinking: { enabled: true,
+// streamThinking: true } for both profiles, which normalizes to
+// { type: "adaptive" } on the wire. Off-platform (BYOK) instances pick this
+// up on every boot because the seeder overwrites managed profiles. On-platform
+// instances preserve existing profiles (the platform overlay is authoritative),
+// so instances that were hatched before thinking was enabled in the templates
+// are stuck with thinking disabled or absent.
+//
+// This migration patches the on-disk config for both profiles, adding
+// thinking: { enabled: true, streamThinking: true } where it's missing or
+// explicitly disabled. It skips profiles that:
+//   - Don't exist (no profile to patch)
+//   - Already have thinking enabled (idempotent)
+//   - Are not source: "managed" (user-created profiles are untouched)
+//   - Use a non-Anthropic provider (adaptive thinking is Anthropic-specific)
+
+const ADAPTIVE_THINKING = { enabled: true, streamThinking: true } as const;
+const TARGET_PROFILES = ["balanced", "quality-optimized"] as const;
+
+export const enableAdaptiveThinkingManagedProfilesMigration: WorkspaceMigration =
+  {
+    id: "097-enable-adaptive-thinking-managed-profiles",
+    description:
+      "Enable adaptive thinking on managed balanced and quality-optimized profiles",
+    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;
+      }
+
+      const llm = readObject(config.llm);
+      if (llm === null) return;
+
+      const profiles = readObject(llm.profiles);
+      if (profiles === null) return;
+
+      let changed = false;
+
+      for (const name of TARGET_PROFILES) {
+        const profile = readObject(profiles[name]);
+        if (profile === null) continue;
+
+        // Only patch managed Anthropic profiles.
+        if (profile.source !== "managed") continue;
+        if (
+          typeof profile.provider === "string" &&
+          profile.provider !== "anthropic"
+        ) {
+          continue;
+        }
+
+        // Skip if thinking is already enabled.
+        const thinking = readObject(profile.thinking);
+        if (thinking !== null && thinking.enabled === true) continue;
+
+        profile.thinking = { ...ADAPTIVE_THINKING };
+        profiles[name] = profile;
+        changed = true;
+      }
+
+      if (changed) {
+        llm.profiles = profiles;
+        config.llm = llm;
+        writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+      }
+    },
+    down(_workspaceDir: string): void {
+      // Forward-only.
+    },
+  };
+
+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>;
+}

package/src/workspace/migrations/registry.ts

@@ -92,6 +92,9 @@ import { retightenMigrationOnboardingThreadMigration } from "./091-retighten-mig
 import { backfillV3LeavesMigration } from "./092-backfill-v3-leaves.js";
 import { backfillLeafIdsMigration } from "./093-backfill-leaf-ids.js";
 import { seedAvatarManifestMigration } from "./094-seed-avatar-manifest.js";
+import { bumpHeartbeatInterval30mTo60mMigration } from "./095-bump-heartbeat-interval-30m-to-60m.js";
+import { reduceQualityProfileEffortMigration } from "./096-reduce-quality-profile-effort.js";
+import { enableAdaptiveThinkingManagedProfilesMigration } from "./097-enable-adaptive-thinking-managed-profiles.js";
 import { migrateToWorkspaceVolumeMigration } from "./migrate-to-workspace-volume.js";
 import type { WorkspaceMigration } from "./types.js";
 
@@ -195,4 +198,7 @@ export const WORKSPACE_MIGRATIONS: WorkspaceMigration[] = [
   backfillV3LeavesMigration,
   backfillLeafIdsMigration,
   seedAvatarManifestMigration,
+  bumpHeartbeatInterval30mTo60mMigration,
+  reduceQualityProfileEffortMigration,
+  enableAdaptiveThinkingManagedProfilesMigration,
 ];

package/src/__tests__/bootstrap-turn-cleanup.test.ts

@@ -1,44 +0,0 @@
-import { describe, expect, test } from "bun:test";
-
-import {
-  BOOTSTRAP_CLEANUP_USER_TURN_THRESHOLD,
-  countBootstrapUserTurns,
-  shouldCleanupBootstrapAfterTurn,
-} from "../daemon/bootstrap-turn-cleanup.js";
-
-function message(role: string, content: string) {
-  return { role, content };
-}
-
-describe("bootstrap turn cleanup", () => {
-  test("does not count the hidden wake-up greeting as a user turn", () => {
-    const messages = [
-      message(
-        "user",
-        JSON.stringify([{ type: "text", text: "Wake up, my friend." }]),
-      ),
-      message("assistant", "hello"),
-      message("user", "real request"),
-    ];
-
-    expect(countBootstrapUserTurns(messages)).toBe(1);
-  });
-
-  test("cleans up after the configured user-turn threshold", () => {
-    const messages = Array.from(
-      { length: BOOTSTRAP_CLEANUP_USER_TURN_THRESHOLD },
-      (_value, index) => message("user", `request ${index + 1}`),
-    );
-
-    expect(shouldCleanupBootstrapAfterTurn(messages)).toBe(true);
-  });
-
-  test("keeps bootstrap before the configured user-turn threshold", () => {
-    const messages = Array.from(
-      { length: BOOTSTRAP_CLEANUP_USER_TURN_THRESHOLD - 1 },
-      (_value, index) => message("user", `request ${index + 1}`),
-    );
-
-    expect(shouldCleanupBootstrapAfterTurn(messages)).toBe(false);
-  });
-});