@vellumai/assistant 0.8.8 → 0.8.9-staging.1

package/src/tools/acp/steer.test.ts

@@ -7,6 +7,7 @@ interface SteerCall {
   instruction: string;
 }
 
+// Direct steer (no connected client -> no resume fallback).
 const steerCalls: SteerCall[] = [];
 const defaultSteer = (acpSessionId: string, instruction: string) => {
   steerCalls.push({ acpSessionId, instruction });
@@ -15,6 +16,13 @@ const defaultSteer = (acpSessionId: string, instruction: string) => {
 let steerImpl: (acpSessionId: string, instruction: string) => Promise<void> =
   defaultSteer;
 
+// steerOrResume (connected client path).
+const steerOrResumeCalls: Array<SteerCall & { send: unknown }> = [];
+let steerOrResumeImpl: (
+  acpSessionId: string,
+  instruction: string,
+) => Promise<{ resumed: boolean }> = async () => ({ resumed: false });
+
 // Spread the real module's exports so transitive importers that pull other
 // names from `../../acp/index.js` still resolve at parse time. Bun's `mock.module` is
 // process-global and returns *exactly* the keys the factory returns.
@@ -24,35 +32,50 @@ mock.module("../../acp/index.js", () => ({
   getAcpSessionManager: () => ({
     steer: (acpSessionId: string, instruction: string) =>
       steerImpl(acpSessionId, instruction),
+    steerOrResume: (
+      acpSessionId: string,
+      instruction: string,
+      send: unknown,
+    ) => {
+      steerOrResumeCalls.push({ acpSessionId, instruction, send });
+      return steerOrResumeImpl(acpSessionId, instruction);
+    },
   }),
 }));
 
 const { executeAcpSteer } = await import("./steer.js");
 
-function makeContext(): ToolContext {
+function makeContext(opts?: { withClient?: boolean }): ToolContext {
   return {
     workingDir: "/tmp",
     conversationId: "conv-test",
     trustClass: "guardian",
-  };
+    ...(opts?.withClient ? { sendToClient: () => {} } : {}),
+  } as ToolContext;
 }
 
 beforeEach(() => {
   steerCalls.length = 0;
+  steerOrResumeCalls.length = 0;
   steerImpl = defaultSteer;
+  steerOrResumeImpl = async () => ({ resumed: false });
 });
 
 describe("executeAcpSteer", () => {
-  test("happy path: returns steered status and forwards args to manager", async () => {
+  test("happy path: returns steered status and forwards args to steerOrResume", async () => {
     const result = await executeAcpSteer(
       { acp_session_id: "acp-123", instruction: "stop, do X instead" },
-      makeContext(),
+      makeContext({ withClient: true }),
     );
 
     expect(result.isError).toBe(false);
-    expect(steerCalls).toEqual([
-      { acpSessionId: "acp-123", instruction: "stop, do X instead" },
-    ]);
+    expect(steerOrResumeCalls).toHaveLength(1);
+    expect(steerOrResumeCalls[0]).toMatchObject({
+      acpSessionId: "acp-123",
+      instruction: "stop, do X instead",
+    });
+    expect(typeof steerOrResumeCalls[0]!.send).toBe("function");
+    expect(steerCalls).toEqual([]);
 
     const parsed = JSON.parse(result.content as string);
     expect(parsed).toEqual({
@@ -71,6 +94,7 @@ describe("executeAcpSteer", () => {
     expect(result.isError).toBe(true);
     expect(result.content).toContain('"instruction" is required');
     expect(steerCalls).toEqual([]);
+    expect(steerOrResumeCalls).toEqual([]);
   });
 
   test("missing acp_session_id returns isError", async () => {
@@ -82,9 +106,23 @@ describe("executeAcpSteer", () => {
     expect(result.isError).toBe(true);
     expect(result.content).toContain('"acp_session_id" is required');
     expect(steerCalls).toEqual([]);
+    expect(steerOrResumeCalls).toEqual([]);
+  });
+
+  test("no connected client: steers directly and never resumes", async () => {
+    const result = await executeAcpSteer(
+      { acp_session_id: "acp-direct", instruction: "redirect" },
+      makeContext(),
+    );
+
+    expect(result.isError).toBe(false);
+    expect(steerCalls).toEqual([
+      { acpSessionId: "acp-direct", instruction: "redirect" },
+    ]);
+    expect(steerOrResumeCalls).toEqual([]);
   });
 
-  test("manager.steer throwing 'session not found' surfaces the error", async () => {
+  test("'session not found' without a connected client surfaces the error", async () => {
     steerImpl = () =>
       Promise.reject(new Error('ACP session "acp-x" not found'));
 
@@ -96,5 +134,64 @@ describe("executeAcpSteer", () => {
     expect(result.isError).toBe(true);
     expect(result.content).toContain('Could not steer ACP session "acp-x"');
     expect(result.content).toContain("not found");
+    expect(steerOrResumeCalls).toEqual([]);
+  });
+
+  test("resumed session reports the resumed flag and message", async () => {
+    steerOrResumeImpl = async () => ({ resumed: true });
+
+    const result = await executeAcpSteer(
+      { acp_session_id: "acp-gone", instruction: "keep going" },
+      makeContext({ withClient: true }),
+    );
+
+    expect(result.isError).toBe(false);
+    expect(steerOrResumeCalls).toHaveLength(1);
+
+    const parsed = JSON.parse(result.content as string);
+    expect(parsed).toEqual({
+      acpSessionId: "acp-gone",
+      status: "steered",
+      resumed: true,
+      message:
+        "Session was resumed from history; new instruction is now running.",
+    });
+  });
+
+  test("resume failure returns its actionable error message", async () => {
+    steerOrResumeImpl = () =>
+      Promise.reject(
+        new Error(
+          'ACP session "acp-legacy" was recorded before resume support (no working directory persisted) and cannot be resumed. Spawn a new session instead.',
+        ),
+      );
+
+    const result = await executeAcpSteer(
+      { acp_session_id: "acp-legacy", instruction: "more work" },
+      makeContext({ withClient: true }),
+    );
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain(
+      'Could not steer ACP session "acp-legacy"',
+    );
+    expect(result.content).toContain("recorded before resume support");
+  });
+
+  test("plain steer errors surface unchanged", async () => {
+    steerOrResumeImpl = () =>
+      Promise.reject(
+        new Error(
+          'ACP session "acp-init" is not running (status: initializing)',
+        ),
+      );
+
+    const result = await executeAcpSteer(
+      { acp_session_id: "acp-init", instruction: "redirect" },
+      makeContext({ withClient: true }),
+    );
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain("is not running");
   });
 });

package/src/tools/acp/steer.ts

@@ -1,9 +1,10 @@
 import { getAcpSessionManager } from "../../acp/index.js";
 import type { ToolContext, ToolExecutionResult } from "../types.js";
+import { getSendToClient } from "./context.js";
 
 export async function executeAcpSteer(
   input: Record<string, unknown>,
-  _context: ToolContext,
+  context: ToolContext,
 ): Promise<ToolExecutionResult> {
   const acpSessionId = input.acp_session_id as string;
   if (!acpSessionId) {
@@ -15,24 +16,54 @@ export async function executeAcpSteer(
     return { content: '"instruction" is required.', isError: true };
   }
 
-  try {
-    const manager = getAcpSessionManager();
-    await manager.steer(acpSessionId, instruction);
+  const manager = getAcpSessionManager();
+  const sendToClient = getSendToClient(context);
 
-    return {
-      content: JSON.stringify({
-        acpSessionId,
-        status: "steered",
-        message:
-          "Interrupted in-flight prompt; new instruction is now running.",
-      }),
-      isError: false,
-    };
+  try {
+    if (!sendToClient) {
+      // Without a connected client there is no one to receive a resumed
+      // session's events, so skip the transparent resume fallback and
+      // steer the in-memory session only.
+      await manager.steer(acpSessionId, instruction);
+      return steeredResult(acpSessionId, { resumed: false });
+    }
+    // Sessions no longer in memory (completed, or lost to a daemon
+    // restart) are transparently resumed from persisted history and the
+    // instruction fired in the same call. Failure messages carry the
+    // actionable hint (e.g. "recorded before resume support", agent
+    // capability missing).
+    const { resumed } = await manager.steerOrResume(
+      acpSessionId,
+      instruction,
+      sendToClient,
+    );
+    return steeredResult(acpSessionId, { resumed });
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
-    return {
-      content: `Could not steer ACP session "${acpSessionId}": ${msg}`,
-      isError: true,
-    };
+    return steerError(acpSessionId, msg);
   }
 }
+
+function steeredResult(
+  acpSessionId: string,
+  opts: { resumed: boolean },
+): ToolExecutionResult {
+  return {
+    content: JSON.stringify({
+      acpSessionId,
+      status: "steered",
+      ...(opts.resumed ? { resumed: true } : {}),
+      message: opts.resumed
+        ? "Session was resumed from history; new instruction is now running."
+        : "Interrupted in-flight prompt; new instruction is now running.",
+    }),
+    isError: false,
+  };
+}
+
+function steerError(acpSessionId: string, msg: string): ToolExecutionResult {
+  return {
+    content: `Could not steer ACP session "${acpSessionId}": ${msg}`,
+    isError: true,
+  };
+}

package/src/tools/apps/executors.ts

@@ -76,14 +76,12 @@ export interface AppCreateInput {
   name: string;
   description?: string;
   schema_json?: string;
-  /**
-   * Retired single-file shortcut. Kept in the type so legacy or stale callers
-   * get a clear tool error instead of silently creating a v2 app with stale
-   * scaffold content.
-   */
+  /** Retired single-file shortcut. Returns a guidance error. */
   html?: unknown;
-  /** Retired single-file multi-page shortcut. */
+  /** Retired single-file multi-page shortcut. Returns a guidance error. */
   pages?: unknown;
+  /** Lenient alias. Folded into preview.icon when preview.icon is absent. */
+  icon?: unknown;
   auto_open?: boolean;
   preview?: Record<string, unknown>;
   source_files?: Record<string, string>;
@@ -98,11 +96,14 @@ export async function executeAppCreate(
   const description = input.description;
   const schemaJson = input.schema_json ?? "{}";
 
+  // Retired shortcut: a top-level `html` is no longer accepted. Reject with a
+  // helpful message (rather than a cryptic schema error) so the model writes a
+  // multi-file TSX app under src/ instead.
   if (Object.prototype.hasOwnProperty.call(input, "html")) {
     return {
       content: JSON.stringify({
         error:
-          "app_create no longer accepts html. Create the app scaffold, write src/index.html and src/main.tsx with file_write, then call app_refresh.",
+          "app_create no longer accepts html. Build a multi-file TSX app under src/ (src/index.html + src/main.tsx + src/App.tsx) instead.",
       }),
       isError: true,
     };
@@ -157,7 +158,11 @@ export async function executeAppCreate(
 
   // Extract icon from preview if provided - only persist emoji-like values,
   // not URLs which would render as raw strings in UI and bundle manifests.
-  const rawIcon = preview?.icon as string | undefined;
+  // Lenient alias: a top-level `icon` is folded in when preview.icon is absent.
+  const rawIcon = (preview?.icon ??
+    (typeof input.icon === "string" ? input.icon : undefined)) as
+    | string
+    | undefined;
   const icon = rawIcon && !rawIcon.startsWith("http") ? rawIcon : undefined;
 
   const app = store.createApp({

package/src/tools/filesystem/write.ts

@@ -1,5 +1,6 @@
 import { join, resolve, sep } from "node:path";
 
+import { getAppsDir } from "../../memory/app-store.js";
 import { enqueuePkbIndexJob } from "../../memory/jobs/embed-pkb-file.js";
 import { PKB_WORKSPACE_SCOPE } from "../../memory/pkb/types.js";
 import { RiskLevel } from "../../permissions/types.js";
@@ -17,6 +18,29 @@ import type {
 
 const logger = getLogger("file-write");
 
+/**
+ * Detects an attempt to write a self-contained interactive HTML document —
+ * the signature of a "visualization" / "artifact" the model should be
+ * building as a real app via the app-builder skill, not dumping as a loose
+ * file. We deliberately trip ONLY on standalone docs with a substantial
+ * INLINE script (the data + rendering live in the file). app-builder's own
+ * scaffold writes a thin shell whose only script is an external module
+ * (`<script type="module" src="/src/main.tsx">`) with an empty body, so this
+ * never blocks the app-builder workflow it redirects to.
+ */
+const STANDALONE_HTML_RE = /<!doctype\s+html|<html[\s>]/i;
+const INLINE_SCRIPT_RE = /<script\b(?![^>]*\bsrc=)[^>]*>[\s\S]{400,}?<\/script>/i;
+
+function isSelfContainedArtifactHtml(path: string, content: string): boolean {
+  if (!/\.html?$/i.test(path)) return false;
+  if (content.length < 3000) return false;
+  if (!STANDALONE_HTML_RE.test(content)) return false;
+  return INLINE_SCRIPT_RE.test(content);
+}
+
+const ARTIFACT_REDIRECT_MESSAGE =
+  'Error: This looks like a self-contained interactive visualization/artifact written as a loose HTML file. Do not build these as standalone .html files. Load the app-builder skill first with `skill_load` using `skill: "app-builder"`, then build it as a real persistent app with `app_create` (the skill loads frontend-design for the visual pass and provides chart widgets). If this genuinely needs to be a raw HTML file inside an existing code project, write it under that project folder.';
+
 /**
  * Returns `true` iff `absPath` is an absolute path that resolves strictly
  * inside `pkbRoot`. Matches the containment semantics used elsewhere in the
@@ -82,6 +106,16 @@ export const fileWriteTool = {
       };
     }
 
+    // Redirect self-contained interactive HTML artifacts to app-builder.
+    // Exempt writes that land inside the apps directory (app-builder's own
+    // scaffold/iteration writes) so we never block the workflow we point to.
+    if (isSelfContainedArtifactHtml(rawPath, fileContent)) {
+      const candidate = resolve(context.workingDir, rawPath);
+      if (!isInsidePkbRoot(candidate, getAppsDir())) {
+        return { content: ARTIFACT_REDIRECT_MESSAGE, isError: true };
+      }
+    }
+
     const ops = new FileSystemOps((path, opts) =>
       sandboxPolicy(path, context.workingDir, opts),
     );

package/src/tools/subagent/spawn.ts

@@ -1,4 +1,4 @@
-import { findConversation } from "../../daemon/conversation-store.js";
+import { findConversation } from "../../daemon/conversation-registry.js";
 import { getConversationOverrideProfile } from "../../memory/conversation-crud.js";
 import type { Message } from "../../providers/types.js";
 import { getSubagentManager } from "../../subagent/index.js";
@@ -102,9 +102,7 @@ export async function executeSubagentSpawn(
         ...(inheritedOverrideProfile
           ? { overrideProfile: inheritedOverrideProfile }
           : {}),
-        ...(context.toolUseId
-          ? { parentToolUseId: context.toolUseId }
-          : {}),
+        ...(context.toolUseId ? { parentToolUseId: context.toolUseId } : {}),
         ...forkFields,
       },
       sendToClient as (msg: unknown) => void,

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

@@ -19,7 +19,7 @@ import type {
 // ---------------------------------------------------------------------------
 
 const APP_BUILDER_ARTIFACT_RE =
-  /\b(app|apps|application|applications|website|websites|site|sites|dashboard|dashboards|game|games|calculator|calculators|tracker|trackers|visualization|visualizations|visualisation|visualisations|tool|tools|utility|utilities|counter|counters)\b/i;
+  /\b(app|apps|application|applications|website|websites|site|sites|dashboard|dashboards|game|games|calculator|calculators|tracker|trackers|visualization|visualizations|visualisation|visualisations|visualize|visualise|artifact|artifacts|chart|charts|graph|graphs|tool|tools|utility|utilities|counter|counters)\b/i;
 const APP_BUILDER_BUILD_RE =
   /\b(build|building|built|create|creating|created|make|making|made|generate|generating|generated)\b/i;
 
@@ -58,11 +58,31 @@ function isDynamicPageAppSubstitute(input: Record<string, unknown>): boolean {
   }
 
   const text = collectRoutingText(input).join(" ");
-  if (!APP_BUILDER_ARTIFACT_RE.test(text)) {
-    return false;
+  if (
+    APP_BUILDER_ARTIFACT_RE.test(text) &&
+    (APP_BUILDER_BUILD_RE.test(text) || /\b(app|application)\b/i.test(text))
+  ) {
+    return true;
   }
 
-  return APP_BUILDER_BUILD_RE.test(text) || /\b(app|application)\b/i.test(text);
+  // Second signal: even when the model gives the surface a clean,
+  // non-app-sounding title (dodging the text regex above), substantial
+  // interactive HTML is an app being smuggled in as a transient surface.
+  // A genuinely transient page is small and static; an app has real
+  // scripted markup. Keep the bar high so simple snippets still pass.
+  return isSubstantialInteractiveHtml(input);
+}
+
+const INTERACTIVE_HTML_RE =
+  /<script\b|on[a-z]+\s*=|addEventListener|new Chart\b|window\.vellum\b/i;
+
+function isSubstantialInteractiveHtml(input: Record<string, unknown>): boolean {
+  const data = asRecord(input.data);
+  const html = data?.html;
+  if (typeof html !== "string") {
+    return false;
+  }
+  return html.length > 2000 && INTERACTIVE_HTML_RE.test(html);
 }
 
 function collectRoutingText(input: Record<string, unknown>): string[] {
@@ -116,7 +136,7 @@ export const uiShowTool = {
     "- file_upload: { prompt, acceptedTypes?, maxFiles? }\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.",
+    "Emit a task_progress card BEFORE your first tool call on any multi-step, long-running, or post-form turn (web searches, file operations, research), and keep its steps updated as work progresses. Skills that estimate >30s of work should declare progress upfront with concrete step labels (and counts when known).",
   category: "ui-surface",
   defaultRiskLevel: RiskLevel.Low,
   executionTarget: "host",

package/src/workspace/migrations/051-seed-conversation-summarization-callsite.ts

@@ -9,10 +9,9 @@ import type { WorkspaceMigration } from "./types.js";
  * `conversationSummarization` is invoked from `ContextWindowManager.
  * updateSummary()` during mid-loop compaction. Without a call-site entry it
  * falls through to `llm.default` (opus + `effort: "max"` + `thinking:
- * { enabled: true }` + `maxTokens: 64000`), which is far too expensive for
- * summarizing a ~150k-token transcript inside the agent-loop plugin
- * pipeline's 30s budget — we were hitting `PluginTimeoutError` and hard-
- * failing the turn.
+ * { enabled: true }` + `maxTokens: 64000`), which is far too expensive and
+ * slow for summarizing a ~150k-token transcript inside the agent loop —
+ * the summary call would stall the turn.
  *
  * This migration seeds `effort: "low"` and `thinking: { enabled: false }`
  * (and opus-4.7 as the model when absent) so the summary call runs cheaply
@@ -99,7 +98,7 @@ export const seedConversationSummarizationCallsiteMigration: WorkspaceMigration
     },
     down(_workspaceDir: string): void {
       // Forward-only: removing the seeded defaults would reintroduce the
-      // 30s pipeline-budget timeout this migration fixes.
+      // expensive, slow summary call this migration fixes.
     },
   };
 

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

@@ -20,65 +20,89 @@ import type { WorkspaceMigration } from "./types.js";
 // 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)
+//   - Are source: "user" (user-created profiles are untouched)
+//   - Have a non-managed, non-absent source (unknown origin)
 //   - 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;
+/**
+ * Patch managed Anthropic profiles that are missing adaptive thinking.
+ *
+ * Exported so lifecycle.ts can re-run the repair after mergeDefaultWorkspaceConfig()
+ * and seedInferenceProfiles(). On-platform instances with a config overlay have their
+ * profiles overwritten by the overlay merge (which runs after workspace migrations),
+ * so the migration alone is insufficient — the post-overlay call ensures the repair
+ * sticks even when the overlay supplies profiles without thinking enabled.
+ *
+ * The function is idempotent: profiles that already have thinking enabled are skipped.
+ */
+export function repairAdaptiveThinkingOnManagedProfiles(
+  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;
-      }
+  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 llm = readObject(config.llm);
+  if (llm === null) return;
 
-      const profiles = readObject(llm.profiles);
-      if (profiles === null) return;
+  const profiles = readObject(llm.profiles);
+  if (profiles === null) return;
 
-      let changed = false;
+  let changed = false;
 
-      for (const name of TARGET_PROFILES) {
-        const profile = readObject(profiles[name]);
-        if (profile === null) continue;
+  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;
-        }
+    // Only patch managed Anthropic profiles.
+    // Legacy profiles created before the `source` metadata field was introduced
+    // have source=undefined. Treat these as managed when the profile name is one
+    // of the canonical managed names (which TARGET_PROFILES already guarantees)
+    // and the provider is Anthropic (or absent). Explicit `source: "user"`
+    // profiles are always skipped.
+    if (profile.source === "user") continue;
+    if (profile.source !== undefined && 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;
+    // 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;
-      }
+    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");
-      }
+  if (changed) {
+    llm.profiles = profiles;
+    config.llm = llm;
+    writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+  }
+}
+
+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 {
+      repairAdaptiveThinkingOnManagedProfiles(workspaceDir);
     },
     down(_workspaceDir: string): void {
       // Forward-only.