@vellumai/assistant 0.10.2-dev.202606250318.5e7cfb0 → 0.10.2

package/src/util/errors.ts

@@ -102,17 +102,6 @@ export class AssistantError extends VellumError {
 export class ProviderError extends AssistantError {
   /** Delay (in ms) suggested by the server's Retry-After header, if present. */
   public readonly retryAfterMs?: number;
-  /** Upstream provider error metadata, parsed from the raw non-2xx body. */
-  public readonly apiErrorCode?: string;
-  public readonly apiErrorType?: string;
-  public readonly apiErrorParam?: string;
-  public readonly requestId?: string;
-  /**
-   * Verbatim upstream non-2xx body (possibly truncated). Persisted so the
-   * inspector's Raw tab can show the actual provider error payload, not just
-   * the extracted fields.
-   */
-  public readonly rawBody?: string;
   /**
    * Tagged daemon-owned abort reason carried over from the AbortSignal that
    * triggered this error. Untyped here to avoid a daemon→util import cycle;
@@ -125,25 +114,11 @@ export class ProviderError extends AssistantError {
     message: string,
     public readonly provider: string,
     public readonly statusCode?: number,
-    options?: {
-      cause?: unknown;
-      retryAfterMs?: number;
-      abortReason?: unknown;
-      apiErrorCode?: string;
-      apiErrorType?: string;
-      apiErrorParam?: string;
-      requestId?: string;
-      rawBody?: string;
-    },
+    options?: { cause?: unknown; retryAfterMs?: number; abortReason?: unknown },
   ) {
     super(message, ErrorCode.PROVIDER_ERROR, options);
     this.name = "ProviderError";
     this.retryAfterMs = options?.retryAfterMs;
-    this.apiErrorCode = options?.apiErrorCode;
-    this.apiErrorType = options?.apiErrorType;
-    this.apiErrorParam = options?.apiErrorParam;
-    this.requestId = options?.requestId;
-    this.rawBody = options?.rawBody;
     this.abortReason = options?.abortReason;
   }
 }

package/src/util/platform.ts

@@ -242,11 +242,6 @@ export function getEmbedWorkerPidPath(): string {
   return join(getWorkspaceDir(), "embed-worker.pid");
 }
 
-/** Returns the path to the memory-worker PID file ($VELLUM_WORKSPACE_DIR/memory-worker.pid). */
-export function getMemoryWorkerPidPath(): string {
-  return join(getWorkspaceDir(), "memory-worker.pid");
-}
-
 /**
  * Returns the workspace root for user-facing state.
  *

package/src/workflows/library.test.ts

@@ -37,13 +37,6 @@ function writeWorkflow(file: string, source: string): void {
   writeFileSync(join(dir, file), source, "utf8");
 }
 
-/** Write `<workspace>/workflows/<name>/workflow.ts` (directory-style). */
-function writeDirWorkflow(name: string, source: string): void {
-  const dir = join(workspaceDir, "workflows", name);
-  mkdirSync(dir, { recursive: true });
-  writeFileSync(join(dir, "workflow.ts"), source, "utf8");
-}
-
 describe("listWorkflows", () => {
   test("returns [] and does not create the dir when none exists", () => {
     expect(listWorkflows()).toEqual([]);
@@ -91,51 +84,6 @@ describe("listWorkflows", () => {
     expect(entries.map((e) => e.name)).toEqual(["real"]);
   });
 
-  test("includes both flat and directory-style workflows", () => {
-    writeWorkflow(
-      "flat.workflow.ts",
-      `export const meta = { name: "flat-wf", description: "flat" };\nreturn 1;`,
-    );
-    writeDirWorkflow(
-      "dir-wf",
-      `export const meta = { name: "dir-wf", description: "dir" };\nreturn 1;`,
-    );
-
-    const entries = listWorkflows().sort((a, b) =>
-      a.name.localeCompare(b.name),
-    );
-    expect(entries.map((e) => e.name)).toEqual(["dir-wf", "flat-wf"]);
-    expect(entries[0]!.path).toContain(join("dir-wf", "workflow.ts"));
-    expect(entries[1]!.path).toContain("flat.workflow.ts");
-  });
-
-  test("ignores a subdir without a workflow.ts and does not recurse deeper", () => {
-    writeWorkflow(
-      "real.workflow.ts",
-      `export const meta = { name: "real", description: "d" };\nreturn 1;`,
-    );
-    // Subdir with no entry-point workflow.ts.
-    mkdirSync(join(workspaceDir, "workflows", "empty-dir"), {
-      recursive: true,
-    });
-    writeFileSync(
-      join(workspaceDir, "workflows", "empty-dir", "notes.ts"),
-      `export const meta = { name: "ignored", description: "d" };`,
-      "utf8",
-    );
-    // A nested workflow.ts one level deeper than supported must not be picked up.
-    mkdirSync(join(workspaceDir, "workflows", "outer", "inner"), {
-      recursive: true,
-    });
-    writeFileSync(
-      join(workspaceDir, "workflows", "outer", "inner", "workflow.ts"),
-      `export const meta = { name: "too-deep", description: "d" };`,
-      "utf8",
-    );
-
-    expect(listWorkflows().map((e) => e.name)).toEqual(["real"]);
-  });
-
   test("skips a file whose meta is computed/non-literal (cannot be statically extracted)", () => {
     writeWorkflow(
       "ok.workflow.ts",
@@ -183,92 +131,4 @@ describe("getWorkflow", () => {
     );
     expect(getWorkflow("ghost")).toBeNull();
   });
-
-  test("resolves a directory-style workflow by meta.name", () => {
-    const source = `export const meta = { name: "dir-digest", description: "d" };\nreturn agent("go");`;
-    writeDirWorkflow("dir-digest", source);
-
-    const resolved = getWorkflow("dir-digest");
-    expect(resolved).not.toBeNull();
-    expect(resolved!.source).toBe(source);
-    expect(resolved!.path).toContain(join("dir-digest", "workflow.ts"));
-  });
-
-  test("resolves a directory-style workflow by directory name when meta.name differs", () => {
-    // meta.name is "canonical" but the dir (and caller's name) is "by-dir".
-    const source = `export const meta = { name: "canonical", description: "d" };\nreturn 1;`;
-    writeDirWorkflow("by-dir", source);
-
-    expect(getWorkflow("by-dir")!.source).toBe(source);
-    // The canonical meta.name also resolves.
-    expect(getWorkflow("canonical")!.source).toBe(source);
-  });
-
-  test("prefers a meta.name match over a base-name match", () => {
-    // Asking for "wanted" should hit the file whose meta.name is "wanted",
-    // not the file whose base name is "wanted" (whose meta.name differs).
-    writeWorkflow(
-      "wanted.workflow.ts",
-      `export const meta = { name: "other", description: "by base name" };\nreturn 1;`,
-    );
-    const metaSource = `export const meta = { name: "wanted", description: "by meta name" };\nreturn 1;`;
-    writeWorkflow("real.workflow.ts", metaSource);
-
-    expect(getWorkflow("wanted")!.source).toBe(metaSource);
-  });
-});
-
-describe("name collisions", () => {
-  test("a directory wins over a same-base-name flat file", () => {
-    writeWorkflow(
-      "foo.workflow.ts",
-      `export const meta = { name: "foo", description: "flat" };\nreturn "FLAT";`,
-    );
-    writeDirWorkflow(
-      "foo",
-      `export const meta = { name: "foo", description: "dir" };\nreturn "DIR";`,
-    );
-
-    const resolved = getWorkflow("foo")!;
-    expect(resolved.source).toContain("DIR");
-    expect(resolved.path.endsWith(join("foo", "workflow.ts"))).toBe(true);
-
-    const foos = listWorkflows().filter((e) => e.name === "foo");
-    expect(foos).toHaveLength(1);
-    expect(foos[0]!.description).toBe("dir");
-  });
-
-  test("the shadowed flat file's own meta.name no longer resolves", () => {
-    writeWorkflow(
-      "bar.workflow.ts",
-      `export const meta = { name: "flat-name", description: "flat" };\nreturn "FLAT";`,
-    );
-    writeDirWorkflow(
-      "bar",
-      `export const meta = { name: "dir-name", description: "dir" };\nreturn "DIR";`,
-    );
-
-    expect(getWorkflow("dir-name")!.source).toContain("DIR");
-    expect(getWorkflow("flat-name")).toBeNull();
-    // Base-name fallback also lands on the directory.
-    expect(getWorkflow("bar")!.source).toContain("DIR");
-    expect(listWorkflows().map((e) => e.name)).toEqual(["dir-name"]);
-  });
-
-  test("listWorkflows dedups a duplicate meta.name across different files", () => {
-    writeWorkflow(
-      "a.workflow.ts",
-      `export const meta = { name: "dup", description: "from-a" };\nreturn "A";`,
-    );
-    writeDirWorkflow(
-      "b",
-      `export const meta = { name: "dup", description: "from-b" };\nreturn "B";`,
-    );
-
-    // One entry; the directory (yielded first) wins, consistent with getWorkflow.
-    const dups = listWorkflows().filter((e) => e.name === "dup");
-    expect(dups).toHaveLength(1);
-    expect(dups[0]!.description).toBe("from-b");
-    expect(getWorkflow("dup")!.source).toContain("B");
-  });
 });

package/src/workflows/library.ts

@@ -2,17 +2,13 @@
  * Saved-workflow LIBRARY — named workflows the assistant can invoke by name and
  * the scheduler can trigger.
  *
- * Saved workflows live at `<workspace>/workflows/`. The preferred layout is
- * directory-style `<name>/workflow.ts` (so a workflow and its state can sit in
- * one folder); flat `<name>.workflow.ts` is still supported but discouraged. On
- * a base-name collision the directory wins. Each is a normal workflow script: a
- * leading literal
- * `export const meta = { name, description }` followed by the script body. The
- * library only reads the STATIC `meta` (via {@link extractWorkflowMeta}, a
- * pure-literal extractor that never executes the untrusted source — only the
- * QuickJS sandbox may run it) and the raw source. Resolution to an actual run
- * goes through {@link executeWorkflow} / {@link WorkflowRunManager}, which run
- * the source in the sandbox.
+ * Saved workflows live at `<workspace>/workflows/*.workflow.ts`. Each file is a
+ * normal workflow script: a leading literal `export const meta = { name,
+ * description }` followed by the script body. The library only reads the STATIC
+ * `meta` (via {@link extractWorkflowMeta}, a pure-literal extractor that never
+ * executes the untrusted source — only the QuickJS sandbox may run it) and the
+ * raw source. Resolution to an actual run goes through {@link executeWorkflow} /
+ * {@link WorkflowRunManager}, which run the source in the sandbox.
  *
  * The directory is read lazily and is NOT created eagerly: if it does not exist,
  * {@link listWorkflows} returns `[]` and {@link getWorkflow} returns `null`.
@@ -23,7 +19,7 @@ import { join } from "node:path";
 
 import { getLogger } from "../util/logger.js";
 import { getWorkspaceDir } from "../util/platform.js";
-import { extractWorkflowMeta, type WorkflowMeta } from "./engine.js";
+import { extractWorkflowMeta } from "./engine.js";
 
 const log = getLogger("workflow-library");
 
@@ -53,66 +49,31 @@ function workflowsDir(): string {
   return join(getWorkspaceDir(), "workflows");
 }
 
-/** Filename of the entry-point script inside a directory-style workflow. */
-const DIRECTORY_ENTRY = "workflow.ts";
-
 /** The filename (sans `.workflow.ts`) for `<workspace>/workflows/<base>.workflow.ts`. */
 function fileBaseName(file: string): string {
   return file.slice(0, -WORKFLOW_SUFFIX.length);
 }
 
-/** A saved workflow read off disk, before meta extraction. */
+/** A `*.workflow.ts` file read off disk, before meta extraction. */
 interface RawWorkflowFile {
-  /** Base identity for the filename/dir fallback match (see {@link getWorkflow}). */
-  baseName: string;
+  file: string;
   path: string;
   source: string;
 }
 
 /**
- * Yield every readable saved workflow in a STABLE order (the raw filesystem
- * listing order is not guaranteed, so callers that take "the first match" stay
- * deterministic). Directory-style `<name>/workflow.ts` is yielded first and
- * WINS: a flat `<name>.workflow.ts` with the same base name is shadowed (skipped
- * with a warning). Yields nothing if the directory does not exist — it is never
- * created. An unreadable entry is skipped with a logged warning.
+ * Yield every readable `*.workflow.ts` file in the workflows directory (each read
+ * once). Returns nothing if the directory does not exist — it is never created.
+ * An unreadable file is skipped with a logged warning.
  */
 function* readWorkflowFiles(): Generator<RawWorkflowFile> {
   const dir = workflowsDir();
   if (!existsSync(dir)) return;
-  const entries = readdirSync(dir).sort();
-  const seen = new Set<string>();
-
-  // Directory-style first, so it wins over a same-base-name flat file.
-  for (const entry of entries) {
-    if (entry.endsWith(WORKFLOW_SUFFIX)) continue;
-    const path = join(dir, entry, DIRECTORY_ENTRY);
-    if (!existsSync(path)) continue;
-    try {
-      const source = readFileSync(path, "utf8");
-      seen.add(entry);
-      yield { baseName: entry, path, source };
-    } catch (err) {
-      log.warn({ err, path }, "Failed to read saved workflow; skipping");
-    }
-  }
-
-  // Flat files second; skip any shadowed by a directory of the same base name.
-  for (const entry of entries) {
-    if (!entry.endsWith(WORKFLOW_SUFFIX)) continue;
-    const baseName = fileBaseName(entry);
-    const path = join(dir, entry);
-    if (seen.has(baseName)) {
-      log.warn(
-        { path },
-        `Flat workflow "${entry}" is shadowed by directory "${baseName}/"; skipping`,
-      );
-      continue;
-    }
+  for (const file of readdirSync(dir)) {
+    if (!file.endsWith(WORKFLOW_SUFFIX)) continue;
+    const path = join(dir, file);
     try {
-      const source = readFileSync(path, "utf8");
-      seen.add(baseName);
-      yield { baseName, path, source };
+      yield { file, path, source: readFileSync(path, "utf8") };
     } catch (err) {
       log.warn({ err, path }, "Failed to read saved workflow; skipping");
     }
@@ -120,57 +81,42 @@ function* readWorkflowFiles(): Generator<RawWorkflowFile> {
 }
 
 /**
- * List every saved workflow with a statically-extractable `meta`, deduplicated
- * by `meta.name` — the first in {@link readWorkflowFiles}' stable order wins, a
- * later duplicate is skipped with a warning (matching {@link getWorkflow}'s
- * winner). A file whose `meta` cannot be statically extracted is skipped with a
- * warning rather than failing the whole listing.
+ * List every saved workflow with a statically-extractable `meta`. A file whose
+ * `meta` cannot be statically extracted (computed/missing/malformed) is SKIPPED
+ * with a logged warning rather than failing the whole listing.
  */
 export function listWorkflows(): SavedWorkflowEntry[] {
   const entries: SavedWorkflowEntry[] = [];
-  const seenNames = new Set<string>();
   for (const { path, source } of readWorkflowFiles()) {
-    let meta: WorkflowMeta;
     try {
-      meta = extractWorkflowMeta(source);
+      const meta = extractWorkflowMeta(source);
+      entries.push({ name: meta.name, description: meta.description, path });
     } catch (err) {
       log.warn(
         { err, path },
         "Saved workflow has no statically-extractable meta; skipping",
       );
-      continue;
-    }
-    if (seenNames.has(meta.name)) {
-      log.warn(
-        { path, name: meta.name },
-        `Duplicate workflow name "${meta.name}"; skipping shadowed entry`,
-      );
-      continue;
     }
-    seenNames.add(meta.name);
-    entries.push({ name: meta.name, description: meta.description, path });
   }
   return entries;
 }
 
 /**
- * Resolve a saved workflow by name, deterministically — {@link readWorkflowFiles}
- * yields in a stable order with directory-over-flat precedence, so "the first
- * match" is well-defined. Matches `meta.name` first (the canonical identity),
- * then falls back to the base name (directory or flat-file). Returns the source
- * + path, or `null` if nothing matches.
+ * Resolve a saved workflow by name. Matches against the workflow's `meta.name`
+ * first, then falls back to the filename base (`<base>.workflow.ts`). Returns the
+ * source + path, or `null` if no saved workflow matches.
  */
 export function getWorkflow(name: string): SavedWorkflowSource | null {
   let fileMatch: SavedWorkflowSource | null = null;
-  for (const { baseName, path, source } of readWorkflowFiles()) {
+  for (const { file, path, source } of readWorkflowFiles()) {
     // Prefer a `meta.name` match — it is the canonical identity.
     try {
       if (extractWorkflowMeta(source).name === name) return { source, path };
     } catch {
       // Fall through: a file with non-extractable meta can still match by name.
     }
-    // Remember the first base-name match as a fallback.
-    if (fileMatch === null && baseName === name) {
+    // Remember the first filename-base match as a fallback.
+    if (fileMatch === null && fileBaseName(file) === name) {
       fileMatch = { source, path };
     }
   }

package/src/workspace/migrations/017-seed-persona-dirs.ts

@@ -8,6 +8,11 @@ import {
 } from "node:fs";
 import { join } from "node:path";
 
+import { desc, eq } from "drizzle-orm";
+
+import { generateUserFileSlug } from "../../contacts/contact-store.js";
+import { getDb } from "../../memory/db-connection.js";
+import { contacts } from "../../memory/schema/contacts.js";
 import type { WorkspaceMigration } from "./types.js";
 
 // ── Inlined helpers ───────────────────────────────────────────────
@@ -117,9 +122,35 @@ export const seedPersonaDirsMigration: WorkspaceMigration = {
     // template from disk, since migration 031 deletes that template file.
     if (content === LEGACY_USER_MD_TEMPLATE_STRIPPED) return;
 
-    // Seed the canonical `users/guardian.md` — the runtime persona resolver
-    // falls back to this name, so no assistant-DB lookup is needed.
-    const destPath = join(workspaceDir, "users", "guardian.md");
+    // Determine destination filename based on guardian contact
+    let destFilename = "guardian.md";
+    try {
+      const db = getDb();
+      const guardian = db
+        .select()
+        .from(contacts)
+        .where(eq(contacts.role, "guardian"))
+        .orderBy(desc(contacts.createdAt))
+        .limit(1)
+        .get();
+
+      if (guardian) {
+        if (guardian.userFile) {
+          destFilename = guardian.userFile;
+        } else {
+          const slug = generateUserFileSlug(guardian.displayName);
+          db.update(contacts)
+            .set({ userFile: slug })
+            .where(eq(contacts.id, guardian.id))
+            .run();
+          destFilename = slug;
+        }
+      }
+    } catch {
+      // DB might not be initialized yet — fall back to guardian.md
+    }
+
+    const destPath = join(workspaceDir, "users", destFilename);
     if (!existsSync(destPath)) {
       copyFileSync(userMdPath, destPath);
     }

package/src/workspace/migrations/019-scope-journal-to-guardian.ts

@@ -8,6 +8,10 @@ import {
 } from "node:fs";
 import { join } from "node:path";
 
+import { desc, eq } from "drizzle-orm";
+
+import { getDb } from "../../memory/db-connection.js";
+import { contacts } from "../../memory/schema/contacts.js";
 import type { WorkspaceMigration } from "./types.js";
 
 export const scopeJournalToGuardianMigration: WorkspaceMigration = {
@@ -36,9 +40,26 @@ export const scopeJournalToGuardianMigration: WorkspaceMigration = {
     });
     if (mdFiles.length === 0) return;
 
-    // Scope under the canonical `guardian` slug — the runtime resolver falls
-    // back to it, so no assistant-DB lookup is needed.
-    const destDir = join(journalDir, "guardian");
+    // Resolve guardian user slug (same pattern as 017-seed-persona-dirs)
+    let slug = "guardian";
+    try {
+      const db = getDb();
+      const guardian = db
+        .select()
+        .from(contacts)
+        .where(eq(contacts.role, "guardian"))
+        .orderBy(desc(contacts.createdAt))
+        .limit(1)
+        .get();
+      if (guardian?.userFile) {
+        slug = guardian.userFile.replace(/\.md$/, "");
+      }
+    } catch {
+      // DB not ready — use fallback "guardian"
+    }
+
+    // Create per-user directory and move files (renameSync preserves birthtimes)
+    const destDir = join(journalDir, slug);
     mkdirSync(destDir, { recursive: true });
     for (const f of mdFiles) {
       const src = join(journalDir, f);

package/src/workspace/migrations/048-remove-workspace-hooks.ts

@@ -1,29 +1,81 @@
 /**
- * Workspace migration 048: retained no-op.
+ * Workspace migration 046: Remove legacy `workspace/hooks/` directory.
  *
- * This migration previously deleted `<workspace>/hooks/`, treating it as dead
- * state. `<workspace>/hooks/` is now a supported surface: standalone hook files
- * placed there are loaded by the hook loader (see `src/hooks/hook-loader.ts`).
- * Deleting it would destroy user-authored hooks — including on workspaces that
- * mount a preseeded `<workspace>/hooks/` before this migration first runs — so
- * the deletion has been removed.
+ * Migration 022 moved `~/.vellum/hooks/` into `$VELLUM_WORKSPACE_DIR/hooks/`.
+ * With the hook system entirely removed, that directory is dead state — it is
+ * no longer read or written by the assistant. This migration deletes the
+ * directory (and everything under it) so stale hook manifests, config, and
+ * executables do not linger in user workspaces.
  *
- * The migration is kept (rather than removed from the registry) so the applied
- * checkpoint sequence stays stable across already-migrated workspaces. It is a
- * no-op on every workspace, new or old.
+ * Idempotent: safe to re-run after interruption. A no-op when the directory
+ * is already absent.
  */
 
+import { existsSync, readdirSync, rmSync, statSync } from "node:fs";
+import { join } from "node:path";
+
+import { getLogger } from "../../util/logger.js";
 import type { WorkspaceMigration } from "./types.js";
 
+const log = getLogger("workspace-migration-048-remove-workspace-hooks");
+
+/**
+ * Count files under `dir` recursively. Best-effort — returns the count we
+ * could successfully stat, and silently skips entries that fail (e.g. a
+ * symlink whose target is missing, a file removed concurrently). This is
+ * only used for log output, so a slightly stale count is acceptable.
+ */
+function countFilesRecursive(dir: string): number {
+  let count = 0;
+  let entries: string[];
+  try {
+    entries = readdirSync(dir);
+  } catch {
+    return 0;
+  }
+  for (const entry of entries) {
+    const entryPath = join(dir, entry);
+    try {
+      const s = statSync(entryPath);
+      if (s.isDirectory()) {
+        count += countFilesRecursive(entryPath);
+      } else {
+        count += 1;
+      }
+    } catch {
+      // best-effort
+    }
+  }
+  return count;
+}
+
 export const removeWorkspaceHooksMigration: WorkspaceMigration = {
   id: "048-remove-workspace-hooks",
-  description: "Retained no-op (workspace/hooks is now a supported surface)",
+  description:
+    "Remove legacy workspace/hooks/ directory now that the hook system is gone",
+
+  run(workspaceDir: string): void {
+    const hooksDir = join(workspaceDir, "hooks");
+    if (!existsSync(hooksDir)) return;
 
-  run(_workspaceDir: string): void {
-    // No-op: `<workspace>/hooks/` is a supported surface and must be preserved.
+    const fileCount = countFilesRecursive(hooksDir);
+    try {
+      rmSync(hooksDir, { recursive: true, force: true });
+      log.info(
+        { path: hooksDir, fileCount },
+        "Removed legacy workspace hooks directory",
+      );
+    } catch (err) {
+      log.warn(
+        { err, path: hooksDir },
+        "Failed to remove legacy workspace hooks directory; leaving in place",
+      );
+    }
   },
 
   down(_workspaceDir: string): void {
-    // No-op: forward-only; nothing to reverse.
+    // Forward-only: the hook system is gone and the directory contained no
+    // data the assistant still consumes. Restoring an empty directory would
+    // just reintroduce dead state.
   },
 };

package/src/workspace/migrations/registry.ts

@@ -108,7 +108,6 @@ import { dropSendDiagnosticsMigration } from "./107-drop-send-diagnostics.js";
 import { dropBalancedEconomyProfileMigration } from "./108-drop-balanced-economy-profile.js";
 import { swapQualityProfileToGlm52Migration } from "./109-swap-quality-profile-to-glm-5p2.js";
 import { flipBalancedProfileToTogetherMigration } from "./110-flip-balanced-profile-to-together.js";
-import { pruneSeededCallsiteDefaultsMigration } from "./111-prune-seeded-callsite-defaults.js";
 import { migrateToWorkspaceVolumeMigration } from "./migrate-to-workspace-volume.js";
 import type { WorkspaceMigration } from "./types.js";
 
@@ -228,5 +227,4 @@ export const WORKSPACE_MIGRATIONS: WorkspaceMigration[] = [
   dropBalancedEconomyProfileMigration,
   swapQualityProfileToGlm52Migration,
   flipBalancedProfileToTogetherMigration,
-  pruneSeededCallsiteDefaultsMigration,
 ];