@vellumai/assistant 0.9.1-staging.1 → 0.10.0-staging.2

package/src/workflows/journal-store.ts

@@ -68,6 +68,9 @@ export interface WorkflowJournalEntry {
   request: unknown;
   result: unknown;
   status: string;
+  /** Per-leaf token usage for a completed agent leaf; undefined otherwise. */
+  inputTokens?: number;
+  outputTokens?: number;
   createdAt: number | null;
 }
 
@@ -111,6 +114,9 @@ export interface AppendJournalEntryInput {
   request?: unknown;
   result?: unknown;
   status: string;
+  /** Per-leaf token usage; set for a completed agent leaf, omitted otherwise. */
+  inputTokens?: number;
+  outputTokens?: number;
 }
 
 // ---------------------------------------------------------------------------
@@ -145,6 +151,8 @@ interface WorkflowJournalRow {
   request_json: string | null;
   result_json: string | null;
   status: string;
+  input_tokens: number | null;
+  output_tokens: number | null;
   created_at: number | null;
 }
 
@@ -194,6 +202,8 @@ function rowToJournalEntry(row: WorkflowJournalRow): WorkflowJournalEntry {
     request: parseJsonColumn(row.request_json),
     result: parseJsonColumn(row.result_json),
     status: row.status,
+    inputTokens: row.input_tokens ?? undefined,
+    outputTokens: row.output_tokens ?? undefined,
     createdAt: row.created_at,
   };
 }
@@ -318,14 +328,17 @@ export function appendJournalEntry(
   rawRun(
     /*sql*/ `
     INSERT INTO workflow_journal (
-      run_id, seq, call_hash, kind, request_json, result_json, status, created_at
-    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+      run_id, seq, call_hash, kind, request_json, result_json, status,
+      input_tokens, output_tokens, created_at
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
     ON CONFLICT(run_id, seq) DO UPDATE SET
       call_hash = excluded.call_hash,
       kind = excluded.kind,
       request_json = excluded.request_json,
       result_json = excluded.result_json,
-      status = excluded.status
+      status = excluded.status,
+      input_tokens = excluded.input_tokens,
+      output_tokens = excluded.output_tokens
     `,
     input.runId,
     input.seq,
@@ -334,6 +347,8 @@ export function appendJournalEntry(
     serializeJsonColumn(input.request),
     serializeJsonColumn(input.result),
     input.status,
+    input.inputTokens ?? null,
+    input.outputTokens ?? null,
     Date.now(),
   );
   return getJournalEntry(input.runId, input.seq)!;

package/src/workflows/run-manager.test.ts

@@ -292,6 +292,7 @@ describe("WorkflowRunManager.abort", () => {
       scriptSource: "export const meta = { name: 'x', description: 'y' }",
       args: {},
       manifest: { tools: [], hostFunctions: [], persona: false },
+      conversationId: "conv-1",
       trustContext: TRUST,
     });
 
@@ -318,6 +319,7 @@ describe("WorkflowRunManager — progress events", () => {
       scriptSource: "export const meta = { name: 'x', description: 'y' }",
       args: {},
       manifest: { tools: [], hostFunctions: [], persona: false },
+      conversationId: "conv-1",
       label: "My Flow",
       trustContext: TRUST,
     });
@@ -330,14 +332,164 @@ describe("WorkflowRunManager — progress events", () => {
     expect(progress).toHaveLength(2);
     expect(progress[0]).toMatchObject({
       type: "workflow_progress",
+      conversationId: "conv-1",
       label: "My Flow",
       phase: "Gathering",
     });
     expect(progress[1]).toMatchObject({
       type: "workflow_progress",
+      conversationId: "conv-1",
       message: "step done",
     });
   });
+
+  test("a run with no conversation broadcasts progress unscoped (no conversationId)", () => {
+    const h = makeHarness();
+    h.manager.start({
+      scriptSource: "export const meta = { name: 'x', description: 'y' }",
+      args: {},
+      manifest: { tools: [], hostFunctions: [], persona: false },
+      label: "My Flow",
+      trustContext: TRUST,
+    });
+
+    const onProgress = h.executeCalls[0]!.onProgress!;
+    onProgress({ type: "phase", title: "Gathering" });
+    onProgress({ type: "log", message: "step done" });
+
+    // `workflow_progress` is a pre-existing event; it still broadcasts for a
+    // conversationless run, just without a `conversationId` (unscoped).
+    const progress = h.broadcasts.filter((b) => b.type === "workflow_progress");
+    expect(progress).toHaveLength(2);
+    expect(progress[0]).toMatchObject({
+      type: "workflow_progress",
+      label: "My Flow",
+      phase: "Gathering",
+    });
+    expect(progress[0]).not.toHaveProperty("conversationId");
+  });
+
+  test("onLeaf start/finish are republished as scoped leaf events", () => {
+    const fakeEngine: WorkflowRunManagerDeps["executeWorkflow"] = (options) => {
+      options.onLeaf?.({
+        type: "leaf_started",
+        seq: 1,
+        label: "Research",
+        phase: "Gather",
+        promptSummary: "look it up",
+      });
+      options.onLeaf?.({
+        type: "leaf_finished",
+        seq: 1,
+        status: "completed",
+        label: "Research",
+        inputTokens: 30,
+        outputTokens: 12,
+        resultSummary: "found it",
+      });
+      return new Promise(() => {}) as ReturnType<
+        WorkflowRunManagerDeps["executeWorkflow"]
+      >;
+    };
+    const h = makeHarness({ engine: fakeEngine });
+
+    const { runId } = h.manager.start({
+      scriptSource: "export const meta = { name: 'x', description: 'y' }",
+      args: {},
+      manifest: { tools: [], hostFunctions: [], persona: false },
+      conversationId: "conv-1",
+      trustContext: TRUST,
+    });
+
+    const started = h.broadcasts.find(
+      (b) => b.type === "workflow_leaf_started",
+    );
+    expect(started).toMatchObject({
+      type: "workflow_leaf_started",
+      runId,
+      conversationId: "conv-1",
+      seq: 1,
+      label: "Research",
+      phase: "Gather",
+      promptSummary: "look it up",
+    });
+
+    const finished = h.broadcasts.find(
+      (b) => b.type === "workflow_leaf_finished",
+    );
+    expect(finished).toMatchObject({
+      type: "workflow_leaf_finished",
+      runId,
+      conversationId: "conv-1",
+      seq: 1,
+      status: "completed",
+      label: "Research",
+      inputTokens: 30,
+      outputTokens: 12,
+      resultSummary: "found it",
+    });
+  });
+
+  test("a run with no conversation gets no onLeaf callback", () => {
+    const h = makeHarness();
+    h.manager.start({
+      scriptSource: "export const meta = { name: 'x', description: 'y' }",
+      args: {},
+      manifest: { tools: [], hostFunctions: [], persona: false },
+      trustContext: TRUST,
+    });
+
+    expect(h.executeCalls[0]!.onLeaf).toBeUndefined();
+  });
+});
+
+describe("WorkflowRunManager.start — workflow_started", () => {
+  test("start with a conversation broadcasts workflow_started carrying toolUseId", () => {
+    const h = makeHarness();
+    const { runId } = h.manager.start({
+      scriptSource: "export const meta = { name: 'x', description: 'y' }",
+      args: {},
+      manifest: { tools: [], hostFunctions: [], persona: false },
+      conversationId: "conv-1",
+      toolUseId: "toolu-abc",
+      label: "My Flow",
+      trustContext: TRUST,
+    });
+
+    const started = h.broadcasts.find((b) => b.type === "workflow_started");
+    expect(started).toMatchObject({
+      type: "workflow_started",
+      runId,
+      conversationId: "conv-1",
+      toolUseId: "toolu-abc",
+      label: "My Flow",
+    });
+  });
+
+  test("start without a conversation broadcasts no workflow_started", () => {
+    const h = makeHarness();
+    h.manager.start({
+      scriptSource: "export const meta = { name: 'x', description: 'y' }",
+      args: {},
+      manifest: { tools: [], hostFunctions: [], persona: false },
+      trustContext: TRUST,
+    });
+
+    expect(h.broadcasts.some((b) => b.type === "workflow_started")).toBe(false);
+  });
+
+  test("resume never broadcasts workflow_started", () => {
+    const h = makeHarness({});
+    seedRun(h, {
+      id: "run-x",
+      status: "interrupted",
+      conversationId: "conv-1",
+    });
+
+    h.manager.resume("run-x");
+
+    expect(h.broadcasts.some((b) => b.type === "workflow_started")).toBe(false);
+  });
 });
 
 describe("WorkflowRunManager — completion", () => {
@@ -364,6 +516,7 @@ describe("WorkflowRunManager — completion", () => {
     expect(completed).toMatchObject({
       type: "workflow_completed",
       runId,
+      conversationId: "conv-1",
       status: "completed",
       agentsSpawned: 4,
       inputTokens: 100,
@@ -418,7 +571,7 @@ describe("WorkflowRunManager — completion", () => {
     expect(h.manager.status(runId)?.result).toBe(big);
   });
 
-  test("no conversationId → completion events fire but no wake", async () => {
+  test("no conversationId → pre-existing events broadcast unscoped; UI events and wake are gated", async () => {
     const h = makeHarness();
     h.manager.start({
       scriptSource: "export const meta = { name: 'x', description: 'y' }",
@@ -435,8 +588,23 @@ describe("WorkflowRunManager — completion", () => {
       outputTokens: 1,
     });
 
-    expect(h.broadcasts.some((b) => b.type === "workflow_completed")).toBe(
-      true,
+    // The pre-existing terminal event still broadcasts (unscoped) so raw SSE
+    // listeners and conversationless scheduled runs are still surfaced.
+    const completed = h.broadcasts.find((b) => b.type === "workflow_completed");
+    expect(completed).toMatchObject({
+      type: "workflow_completed",
+      status: "completed",
+    });
+    expect(completed).not.toHaveProperty("conversationId");
+
+    // The conversation-only signals stay gated: no `workflow_started`, no leaf
+    // events, and no completion wake without an originating conversation.
+    expect(h.broadcasts.some((b) => b.type === "workflow_started")).toBe(false);
+    expect(h.broadcasts.some((b) => b.type === "workflow_leaf_started")).toBe(
+      false,
+    );
+    expect(h.broadcasts.some((b) => b.type === "workflow_leaf_finished")).toBe(
+      false,
     );
     expect(h.wakes).toHaveLength(0);
   });

package/src/workflows/run-manager.ts

@@ -114,6 +114,11 @@ interface StartWorkflowCommon {
    * scheduled run with no chat surface) — the summary is then events-only.
    */
   conversationId?: string;
+  /**
+   * The `skill_execute` tool-use block id that launched this run; forwarded on
+   * `workflow_started` so the client anchors the inline card to the spawn call.
+   */
+  toolUseId?: string;
   /** Human-readable label for display; defaults to the run id. */
   label?: string;
   /** Trust/auth context forwarded to every leaf. */
@@ -215,6 +220,19 @@ export class WorkflowRunManager {
     const controller = new AbortController();
     this.inflight.set(runId, controller);
 
+    // Announce the launch only when there's a conversation to scope it to (the
+    // same gate the in-flight/terminal broadcasts use). `resume` never emits
+    // this — the run already announced itself on its original `start`.
+    if (opts.conversationId) {
+      this.deps.broadcast({
+        type: "workflow_started",
+        runId,
+        conversationId: opts.conversationId,
+        ...(opts.toolUseId ? { toolUseId: opts.toolUseId } : {}),
+        label,
+      });
+    }
+
     // Fire-and-forget: the engine owns its own try/catch and always finishes
     // the run row. We never await it — `start` must return synchronously.
     void this.runToCompletion(
@@ -376,6 +394,14 @@ export class WorkflowRunManager {
     ctx: RunContext,
   ): Promise<void> {
     const config = this.deps.getConfig();
+    // `workflow_progress` / `workflow_completed` always broadcast: a run with no
+    // originating conversation emits them unscoped (no `conversationId`) for raw
+    // SSE listeners and the DB record, preserving the pre-scoping contract that
+    // surfaces conversationless scheduled runs. The conversation-only signals —
+    // `workflow_started`, the `onLeaf` leaf events, and the completion wake —
+    // stay gated on `conversationId` since they exist solely to drive the inline
+    // workflow card in that conversation.
+    const conversationId = ctx.conversationId;
     try {
       const result = await this.deps.executeWorkflow({
         runId,
@@ -393,6 +419,7 @@ export class WorkflowRunManager {
           this.deps.broadcast({
             type: "workflow_progress",
             runId,
+            ...(conversationId ? { conversationId } : {}),
             label,
             agentsSpawned,
             ...(event.type === "phase"
@@ -400,6 +427,41 @@ export class WorkflowRunManager {
               : { message: event.message }),
           });
         },
+        ...(conversationId
+          ? {
+              onLeaf: (event) => {
+                if (event.type === "leaf_started") {
+                  this.deps.broadcast({
+                    type: "workflow_leaf_started",
+                    runId,
+                    conversationId,
+                    seq: event.seq,
+                    ...(event.label !== undefined
+                      ? { label: event.label }
+                      : {}),
+                    ...(event.phase !== undefined
+                      ? { phase: event.phase }
+                      : {}),
+                    promptSummary: event.promptSummary,
+                  });
+                } else {
+                  this.deps.broadcast({
+                    type: "workflow_leaf_finished",
+                    runId,
+                    conversationId,
+                    seq: event.seq,
+                    status: event.status,
+                    ...(event.label !== undefined
+                      ? { label: event.label }
+                      : {}),
+                    inputTokens: event.inputTokens,
+                    outputTokens: event.outputTokens,
+                    resultSummary: event.resultSummary,
+                  });
+                }
+              },
+            }
+          : {}),
       });
 
       const summary = buildCompletionSummary(
@@ -412,6 +474,7 @@ export class WorkflowRunManager {
       this.deps.broadcast({
         type: "workflow_completed",
         runId,
+        ...(conversationId ? { conversationId } : {}),
         status: result.status,
         agentsSpawned: result.agentsSpawned,
         inputTokens: result.inputTokens,
@@ -473,6 +536,7 @@ interface RunContext {
 const VALID_TRUST_CLASSES: ReadonlySet<TrustContext["trustClass"]> = new Set([
   "guardian",
   "trusted_contact",
+  "unverified_contact",
   "unknown",
 ]);
 

package/src/workspace/migrations/105-enable-memory-v3-live-for-new-workspaces.ts

@@ -0,0 +1,63 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+import type { MigrationRunContext, WorkspaceMigration } from "./types.js";
+
+/**
+ * Switch brand-new assistants onto memory-v3 (the live injected memory source)
+ * at creation by persisting `memory.v3.live = true`.
+ *
+ * The schema default is `false`, so existing assistants keep running v2 on
+ * upgrade — this migration writes the value only for freshly-created
+ * workspaces. The value gates v3 via `isMemoryV3Live`; existing assistants are
+ * switched on deliberately, never automatically. Covers every surface (local,
+ * Docker, managed) uniformly because all run workspace migrations on first boot.
+ */
+export const enableMemoryV3LiveForNewWorkspacesMigration: WorkspaceMigration = {
+  id: "105-enable-memory-v3-live-for-new-workspaces",
+  description:
+    "Persist memory.v3.live=true for brand-new workspaces so new assistants run memory-v3 from creation",
+
+  run(workspaceDir: string, ctx?: MigrationRunContext): void {
+    // Only switch new assistants on. Existing workspaces fall through to the
+    // schema default (false) and keep running v2 until enabled explicitly.
+    // Without a context (older callers) treat the workspace as existing.
+    if (!ctx?.isNewWorkspace) return;
+
+    const configPath = join(workspaceDir, "config.json");
+
+    // A fresh workspace may have no config.json yet (schema defaults are
+    // applied in memory at load); create one so the live default persists.
+    let config: Record<string, unknown> = {};
+    if (existsSync(configPath)) {
+      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;
+      }
+    }
+
+    if (config.memory === undefined) config.memory = {};
+    const memory = config.memory;
+    if (!memory || typeof memory !== "object" || Array.isArray(memory)) return;
+    const memoryConfig = memory as Record<string, unknown>;
+
+    if (memoryConfig.v3 === undefined) memoryConfig.v3 = {};
+    const v3 = memoryConfig.v3;
+    if (!v3 || typeof v3 !== "object" || Array.isArray(v3)) return;
+    const v3Config = v3 as Record<string, unknown>;
+
+    // Respect an explicit value already present (idempotent re-runs, or a
+    // hatch-time override that set it deliberately).
+    if ("live" in v3Config) return;
+
+    v3Config.live = true;
+    writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+  },
+
+  down(_workspaceDir: string): void {
+    // Forward-only: cannot distinguish a user's explicit choice from this seed.
+  },
+};

package/src/workspace/migrations/106-drop-collect-usage-data.ts

@@ -0,0 +1,47 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+import type { WorkspaceMigration } from "./types.js";
+
+/**
+ * Drops the `collectUsageData` config key (gating is governed by the platform
+ * `share_analytics` consent). An explicit local opt-out (`collectUsageData:
+ * false`) is preserved as `legacyTelemetryOptOut: true` so telemetry stays off
+ * regardless of platform consent, which defaults to opt-in and cannot be
+ * written by the daemon. A `true`/non-false value carries no opt-out intent, so
+ * the key is removed without setting the marker. The schema strips unknown keys
+ * on the next save, so a stale value is otherwise harmless.
+ */
+export const dropCollectUsageDataMigration: WorkspaceMigration = {
+  id: "106-drop-collect-usage-data",
+  description:
+    "Drop collectUsageData; preserve an explicit opt-out as legacyTelemetryOptOut (telemetry is gated by platform share_analytics consent)",
+  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; // Malformed config — skip
+    }
+
+    if (!("collectUsageData" in config)) return;
+
+    // An explicit opt-out is preserved as a fail-closed marker; any non-false
+    // value carries no opt-out intent.
+    if (config.collectUsageData === false) {
+      config.legacyTelemetryOptOut = true;
+    }
+
+    delete config.collectUsageData;
+    writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+  },
+  down(_workspaceDir: string): void {
+    // No-op: the forward migration only removes a key and sets a fail-closed
+    // marker, so there is nothing to restore.
+  },
+};

package/src/workspace/migrations/107-drop-send-diagnostics.ts

@@ -0,0 +1,47 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+import type { WorkspaceMigration } from "./types.js";
+
+/**
+ * Drops the `sendDiagnostics` config key (crash reporting is governed by the
+ * platform `share_diagnostics` consent). An explicit local opt-out
+ * (`sendDiagnostics: false`) is preserved as `legacyDiagnosticsOptOut: true` so
+ * Sentry stays off regardless of platform consent, which defaults to opt-in and
+ * cannot be written by the daemon. A `true`/non-false value carries no opt-out
+ * intent, so the key is removed without setting the marker. The schema strips
+ * unknown keys on the next save, so a stale value is otherwise harmless.
+ */
+export const dropSendDiagnosticsMigration: WorkspaceMigration = {
+  id: "107-drop-send-diagnostics",
+  description:
+    "Drop sendDiagnostics; preserve an explicit opt-out as legacyDiagnosticsOptOut (crash reporting is gated by platform share_diagnostics consent)",
+  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; // Malformed config — skip
+    }
+
+    if (!("sendDiagnostics" in config)) return;
+
+    // An explicit opt-out is preserved as a fail-closed marker; any non-false
+    // value carries no opt-out intent.
+    if (config.sendDiagnostics === false) {
+      config.legacyDiagnosticsOptOut = true;
+    }
+
+    delete config.sendDiagnostics;
+    writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+  },
+  down(_workspaceDir: string): void {
+    // No-op: the forward migration only removes a key and sets a fail-closed
+    // marker, so there is nothing to restore.
+  },
+};

package/src/workspace/migrations/108-drop-balanced-economy-profile.ts

@@ -0,0 +1,129 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+import type { WorkspaceMigration } from "./types.js";
+
+// Reclaim the managed `balanced-economy` inference profile. Its
+// MiniMax-M3-on-Fireworks config lives on `balanced`, whose content the seeder
+// reconciles from the templates on every boot; the seeder never deletes a
+// profile, so this migration deletes the managed `balanced-economy` object and
+// repoints every reference to it — its `profileOrder` entry, the `activeProfile`
+// and `advisorProfile` selections, call-site `profile` overrides, and mix-profile
+// arms — onto `balanced`, which resolves to the same MiniMax M3 route. A
+// `balanced-economy` profile that the user owns (`source !== "managed"`) is left
+// fully intact, references included.
+
+const ECONOMY = "balanced-economy";
+const REPLACEMENT = "balanced";
+
+export const dropBalancedEconomyProfileMigration: WorkspaceMigration = {
+  id: "108-drop-balanced-economy-profile",
+  description:
+    "Remove the managed Balanced Economy profile and repoint its references to Balanced",
+  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);
+    const economy = profiles !== null ? readObject(profiles[ECONOMY]) : null;
+
+    // A user-owned profile that happens to use this name keeps everything,
+    // references included — only the managed profile is reclaimed.
+    if (economy !== null && economy.source !== "managed") return;
+
+    let changed = false;
+
+    if (economy !== null && profiles !== null) {
+      delete profiles[ECONOMY];
+      changed = true;
+    }
+
+    if (Array.isArray(llm.profileOrder)) {
+      const order = llm.profileOrder as unknown[];
+      const pruned = order.filter((name) => name !== ECONOMY);
+      if (pruned.length !== order.length) {
+        llm.profileOrder = pruned;
+        changed = true;
+      }
+    }
+
+    // Repoint call-site overrides — LLMSchema strips a profile name absent from
+    // `llm.profiles` at load, which would drop the equivalent MiniMax route.
+    const callSites = readObject(llm.callSites);
+    if (callSites !== null) {
+      for (const value of Object.values(callSites)) {
+        const site = readObject(value);
+        if (site !== null && site.profile === ECONOMY) {
+          site.profile = REPLACEMENT;
+          changed = true;
+        }
+      }
+    }
+
+    // Repoint mix-profile arms — LLMSchema.superRefine rejects a mix arm whose
+    // referenced profile is absent, failing config validation at load.
+    if (profiles !== null) {
+      for (const value of Object.values(profiles)) {
+        const entry = readObject(value);
+        if (entry === null || !Array.isArray(entry.mix)) continue;
+        for (const arm of entry.mix) {
+          const armObj = readObject(arm);
+          if (armObj !== null && armObj.profile === ECONOMY) {
+            armObj.profile = REPLACEMENT;
+            changed = true;
+          }
+        }
+      }
+    }
+
+    if (llm.activeProfile === ECONOMY) {
+      llm.activeProfile = REPLACEMENT;
+      changed = true;
+
+      // The replaced selection was an enabled profile, so `balanced` must be
+      // usable: a disabled profile is skipped by the resolver and rejected by
+      // validation. Clearing the status sticks because the seeder preserves
+      // whatever status is on disk.
+      const balanced =
+        profiles !== null ? readObject(profiles[REPLACEMENT]) : null;
+      if (balanced !== null && balanced.status === "disabled") {
+        delete balanced.status;
+      }
+    }
+
+    // The advisor selection is the other top-level profile reference
+    // `LLMSchema.superRefine` validates against `llm.profiles`; an unresolvable
+    // value invalidates the config and is stripped at load.
+    if (llm.advisorProfile === ECONOMY) {
+      llm.advisorProfile = REPLACEMENT;
+      changed = true;
+    }
+
+    if (!changed) return;
+
+    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>;
+}