@vellumai/assistant 0.5.0 → 0.5.2

package/src/util/platform.ts

@@ -381,6 +381,11 @@ export function getWorkspaceHooksDir(): string {
   return join(getWorkspaceDir(), "hooks");
 }
 
+/** Returns ~/.vellum/workspace/conversations */
+export function getConversationsDir(): string {
+  return join(getWorkspaceDir(), "conversations");
+}
+
 /** Returns the workspace path for a prompt file (e.g. IDENTITY.md, SOUL.md, USER.md). */
 export function getWorkspacePromptPath(file: string): string {
   return join(getWorkspaceDir(), file);
@@ -399,6 +404,7 @@ export function ensureDataDir(): void {
     join(root, "hooks"),
     join(workspace, "skills"),
     join(workspace, "embedding-models"),
+    join(workspace, "conversations"),
     // Data sub-dirs under workspace
     wsData,
     join(wsData, "db"),

package/src/util/pricing.ts

@@ -25,6 +25,7 @@ const PROVIDER_PRICING: Record<string, Record<string, ModelPricing>> = {
   },
   openai: {
     "gpt-5.4": { inputPer1M: 2.5, outputPer1M: 15 },
+    "gpt-5.4-mini": { inputPer1M: 0.5, outputPer1M: 3 },
     "gpt-5.4-nano": { inputPer1M: 0.2, outputPer1M: 1.25 },
     "gpt-5.2": { inputPer1M: 1.75, outputPer1M: 14 },
     "gpt-4o": { inputPer1M: 2.5, outputPer1M: 10 },

package/src/util/retry.ts

@@ -108,9 +108,7 @@ export function isRetryableNetworkError(error: unknown): boolean {
 
   // Fall back to message-based detection for errors without errno codes
   // (e.g. Bun's "The socket connection was closed unexpectedly")
-  if (
-    RETRYABLE_NETWORK_MESSAGE_PATTERNS.some((p) => p.test(error.message))
-  ) {
+  if (RETRYABLE_NETWORK_MESSAGE_PATTERNS.some((p) => p.test(error.message))) {
     return true;
   }
 

package/src/workspace/migrations/002-backfill-installation-id.ts

@@ -16,8 +16,8 @@ export const backfillInstallationIdMigration: WorkspaceMigration = {
     "Backfill installationId into lockfile from SQLite checkpoint and clean up stale row",
   run(_workspaceDir: string): void {
     // a. Read existing installation ID from SQLite, or generate a new one.
-    //    On fresh installs the memory_checkpoints table may not exist yet
-    //    (workspace migrations run before initializeDb), so treat errors as null.
+    //    On fresh installs the memory_checkpoints table may not exist yet,
+    //    so treat errors as null.
     let existingId: string | null = null;
     try {
       existingId = getMemoryCheckpoint("telemetry:installation_id");
@@ -26,19 +26,30 @@ export const backfillInstallationIdMigration: WorkspaceMigration = {
     }
     const installationId = existingId || randomUUID();
 
-    // b. Read the lockfile from the standard path
+    // b. Read the lockfile — check both the current and legacy lockfile paths
+    //    to support installs that haven't migrated the filename yet.
     const base = process.env.BASE_DATA_DIR?.trim() || homedir();
-    const lockPath = join(base, ".vellum.lock.json");
-    if (!existsSync(lockPath)) return;
+    const lockCandidates = [
+      join(base, ".vellum.lock.json"),
+      join(base, ".vellum.lockfile.json"),
+    ];
 
-    let lockData: Record<string, unknown>;
-    try {
-      const raw = JSON.parse(readFileSync(lockPath, "utf-8"));
-      if (!raw || typeof raw !== "object" || Array.isArray(raw)) return;
-      lockData = raw as Record<string, unknown>;
-    } catch {
-      return;
+    let lockPath: string | undefined;
+    let lockData: Record<string, unknown> | undefined;
+    for (const candidate of lockCandidates) {
+      if (!existsSync(candidate)) continue;
+      try {
+        const raw = JSON.parse(readFileSync(candidate, "utf-8"));
+        if (raw && typeof raw === "object" && !Array.isArray(raw)) {
+          lockPath = candidate;
+          lockData = raw as Record<string, unknown>;
+          break;
+        }
+      } catch {
+        // Malformed — try next candidate.
+      }
     }
+    if (!lockPath || !lockData) return;
 
     // c. Find the assistant entry that corresponds to this daemon instance
     const assistants = lockData.assistants as

package/src/workspace/migrations/003-seed-device-id.ts

@@ -1,16 +1,15 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { homedir } from "node:os";
 import { join } from "node:path";
 
-import { getBaseDataDir } from "../../config/env-registry.js";
+import { getDeviceIdBaseDir } from "../../util/device-id.js";
 import type { WorkspaceMigration } from "./types.js";
 
 export const seedDeviceIdMigration: WorkspaceMigration = {
   id: "003-seed-device-id",
   description:
-    "Seed ~/.vellum/device.json deviceId from the most recent lockfile installationId for continuity",
+    "Seed device.json deviceId from the most recent lockfile installationId for continuity",
   run(_workspaceDir: string): void {
-    const base = getBaseDataDir() || homedir();
+    const base = getDeviceIdBaseDir();
     const vellumDir = join(base, ".vellum");
     const devicePath = join(vellumDir, "device.json");
 

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

@@ -83,6 +83,11 @@ export const servicesConfigMigration: WorkspaceMigration = {
       ...existingServices,
     };
 
+    // Legacy top-level fields (provider, model) are the user's actual
+    // configuration from before the services structure existed. If they're
+    // present as strings they take precedence over any `existingServices`
+    // values, which are just defaults written by backfillConfigDefaults().
+    // The spread preserves any extra keys that future backfills may add.
     services.inference = {
       ...(existingServices.inference ?? {}),
       mode: inferenceMode,

package/src/workspace/migrations/008-voice-timeout-and-max-steps.ts

@@ -0,0 +1,12 @@
+import type { WorkspaceMigration } from "./types.js";
+
+export const voiceTimeoutAndMaxStepsMigration: WorkspaceMigration = {
+  id: "008-voice-timeout-and-max-steps",
+  description:
+    "Add elevenlabs.conversationTimeoutSeconds and maxStepsPerSession to config schema (defaults handle new installs; macOS client syncs existing UserDefaults values on startup)",
+  run(_workspaceDir: string): void {
+    // No-op — schema defaults handle new installs.
+    // Existing users: macOS client will sync UserDefaults values
+    // to config on next startup via settings sync endpoints.
+  },
+};

package/src/workspace/migrations/009-backfill-conversation-disk-view.ts

@@ -0,0 +1,10 @@
+import { rebuildConversationDiskViewFromDb } from "./rebuild-conversation-disk-view.js";
+import type { WorkspaceMigration } from "./types.js";
+
+export const backfillConversationDiskViewMigration: WorkspaceMigration = {
+  id: "009-backfill-conversation-disk-view",
+  description: "Rebuild conversation disk view for existing conversations",
+  run(_workspaceDir: string): void {
+    rebuildConversationDiskViewFromDb();
+  },
+};

package/src/workspace/migrations/010-app-dir-rename.ts

@@ -0,0 +1,223 @@
+/**
+ * Workspace migration 010: Rename UUID-based app directories and files to
+ * human-readable slugified names.
+ *
+ * Inline slugify + dedup logic (not imported from app-store) so the migration
+ * remains stable even if runtime code changes in the future.
+ *
+ * Idempotent: safe to re-run after interruption at any point. Handles
+ * partially-renamed states (crash between JSON write and file rename).
+ */
+
+import { execSync } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import {
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  renameSync,
+  unlinkSync,
+  writeFileSync,
+} from "node:fs";
+import { join } from "node:path";
+
+import type { WorkspaceMigration } from "./types.js";
+
+// ---------------------------------------------------------------------------
+// Self-contained slug generation (do NOT import from app-store)
+// ---------------------------------------------------------------------------
+
+function slugify(name: string): string {
+  let slug = name
+    .toLowerCase()
+    .replace(/[^a-z0-9-]/g, "-")
+    .replace(/-{2,}/g, "-")
+    .replace(/^-+|-+$/g, "");
+
+  if (slug.length > 60) {
+    slug = slug.slice(0, 60).replace(/-+$/, "");
+  }
+
+  if (!slug) {
+    slug = `app-${randomUUID().slice(0, 8)}`;
+  }
+
+  return slug;
+}
+
+function generateUniqueDirName(name: string, usedNames: Set<string>): string {
+  const base = slugify(name);
+  if (!usedNames.has(base)) return base;
+  let counter = 2;
+  while (usedNames.has(`${base}-${counter}`)) {
+    counter++;
+  }
+  return `${base}-${counter}`;
+}
+
+/** Defense-in-depth: reject dirNames that could cause path traversal. */
+function isValidDirName(dirName: string): boolean {
+  return (
+    !!dirName &&
+    !dirName.includes("/") &&
+    !dirName.includes("\\") &&
+    !dirName.includes("..") &&
+    dirName === dirName.trim()
+  );
+}
+
+// ---------------------------------------------------------------------------
+// Migration
+// ---------------------------------------------------------------------------
+
+export const appDirRenameMigration: WorkspaceMigration = {
+  id: "010-app-dir-rename",
+  description:
+    "Rename UUID-based app directories and files to human-readable slugified names",
+
+  run(workspaceDir: string): void {
+    const appsDir = join(workspaceDir, "data", "apps");
+    if (!existsSync(appsDir)) return;
+
+    // Read all JSON files (sorted for deterministic ordering)
+    const jsonFiles = readdirSync(appsDir)
+      .filter((f) => f.endsWith(".json"))
+      .sort();
+
+    if (jsonFiles.length === 0) return;
+
+    const usedNames = new Set<string>();
+
+    for (const jsonFile of jsonFiles) {
+      const jsonPath = join(appsDir, jsonFile);
+      let raw: string;
+      try {
+        raw = readFileSync(jsonPath, "utf-8");
+      } catch {
+        continue; // skip unreadable files
+      }
+
+      let parsed: {
+        id?: string;
+        name?: string;
+        dirName?: string;
+      };
+      try {
+        parsed = JSON.parse(raw);
+      } catch {
+        continue; // skip malformed JSON
+      }
+
+      const appId = parsed.id;
+      const appName = parsed.name ?? "untitled";
+      if (!appId) continue;
+
+      // Check if already migrated: has dirName AND filesystem matches
+      if (parsed.dirName && isValidDirName(parsed.dirName)) {
+        const expectedJsonFile = `${parsed.dirName}.json`;
+        if (
+          jsonFile === expectedJsonFile &&
+          existsSync(join(appsDir, parsed.dirName))
+        ) {
+          // Already fully migrated -- just track the name
+          usedNames.add(parsed.dirName);
+          continue;
+        }
+
+        // Partially renamed: JSON has dirName but files may still be at old paths.
+        // Use the dirName from JSON but rename from wherever the files actually are.
+        const dirName = parsed.dirName;
+        usedNames.add(dirName);
+        renameAppFiles(appsDir, jsonFile, appId, dirName, parsed, raw);
+        continue;
+      }
+
+      // No dirName yet -- generate one
+      const dirName = generateUniqueDirName(appName, usedNames);
+      if (!isValidDirName(dirName)) continue; // safety check
+      usedNames.add(dirName);
+      renameAppFiles(appsDir, jsonFile, appId, dirName, parsed, raw);
+    }
+
+    // Best-effort git commit
+    try {
+      const gitDir = join(appsDir, ".git");
+      if (existsSync(gitDir)) {
+        execSync(
+          "git add -A && git commit -m 'Migration 010: rename app dirs to slugified names' --allow-empty",
+          {
+            cwd: appsDir,
+            stdio: "ignore",
+            timeout: 10_000,
+          },
+        );
+      }
+    } catch {
+      // Git failure is non-fatal -- log nothing since we don't have
+      // the logger available in migrations. The next commitAppChange()
+      // call will pick up the renamed files naturally.
+    }
+  },
+};
+
+/**
+ * Rename app files from their current location to dirName-based paths.
+ * Each step checks existence to handle partial completion.
+ */
+function renameAppFiles(
+  appsDir: string,
+  currentJsonFile: string,
+  appId: string,
+  dirName: string,
+  parsed: Record<string, unknown>,
+  _rawJson: string,
+): void {
+  const targetJsonFile = `${dirName}.json`;
+  const targetPreviewFile = `${dirName}.preview`;
+
+  // 1. Rename the app directory: {appId}/ -> {dirName}/
+  const oldDir = join(appsDir, appId);
+  const newDir = join(appsDir, dirName);
+  if (existsSync(oldDir) && !existsSync(newDir) && oldDir !== newDir) {
+    renameSync(oldDir, newDir);
+  } else if (!existsSync(newDir)) {
+    // Directory doesn't exist at either location -- create it
+    mkdirSync(newDir, { recursive: true });
+  }
+
+  // 2. Rename the preview file: {appId}.preview -> {dirName}.preview
+  const oldPreview = join(appsDir, `${appId}.preview`);
+  const newPreview = join(appsDir, targetPreviewFile);
+  if (
+    existsSync(oldPreview) &&
+    !existsSync(newPreview) &&
+    oldPreview !== newPreview
+  ) {
+    renameSync(oldPreview, newPreview);
+  }
+
+  // 3. Rename the JSON file: {currentFilename} -> {dirName}.json
+  //    Also update the dirName field in the JSON content.
+  const currentJsonPath = join(appsDir, currentJsonFile);
+  const targetJsonPath = join(appsDir, targetJsonFile);
+
+  // Update the JSON with dirName field
+  const updatedParsed = { ...parsed, dirName };
+  const updatedJson = JSON.stringify(updatedParsed, null, 2);
+
+  if (currentJsonFile !== targetJsonFile) {
+    // Write to new location, then remove old
+    writeFileSync(targetJsonPath, updatedJson, "utf-8");
+    if (existsSync(currentJsonPath) && currentJsonPath !== targetJsonPath) {
+      try {
+        unlinkSync(currentJsonPath);
+      } catch {
+        // Old file cleanup is best-effort
+      }
+    }
+  } else {
+    // Just update the content in place
+    writeFileSync(targetJsonPath, updatedJson, "utf-8");
+  }
+}

package/src/workspace/migrations/012-rename-conversation-disk-view-dirs.ts

@@ -0,0 +1,64 @@
+/**
+ * Workspace migration 012: Rename legacy conversation disk-view directories
+ * from `{conversationId}_{timestamp}` to `{timestamp}_{conversationId}`.
+ *
+ * Idempotent and conservative:
+ * - skips directories that already use the new format
+ * - skips non-matching directories
+ * - leaves an existing target directory alone rather than clobbering it
+ * - continues past per-directory rename failures
+ */
+
+import { existsSync, readdirSync, renameSync } from "node:fs";
+import { join } from "node:path";
+
+import type { WorkspaceMigration } from "./types.js";
+
+const LEGACY_CONVERSATION_DIR_PATTERN =
+  /^(.*)_(\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2}\.\d{3}Z)$/;
+
+function parseLegacyConversationDirName(
+  dirName: string,
+): { conversationId: string; timestamp: string } | null {
+  const match = dirName.match(LEGACY_CONVERSATION_DIR_PATTERN);
+  if (!match) return null;
+
+  return {
+    conversationId: match[1],
+    timestamp: match[2],
+  };
+}
+
+export const renameConversationDiskViewDirsMigration: WorkspaceMigration = {
+  id: "012-rename-conversation-disk-view-dirs",
+  description:
+    "Rename legacy conversation disk-view directories to timestamp-first names",
+
+  run(workspaceDir: string): void {
+    const conversationsDir = join(workspaceDir, "conversations");
+    if (!existsSync(conversationsDir)) return;
+
+    const entries = readdirSync(conversationsDir, { withFileTypes: true })
+      .filter((entry) => entry.isDirectory())
+      .map((entry) => entry.name)
+      .sort();
+
+    for (const dirName of entries) {
+      const parsed = parseLegacyConversationDirName(dirName);
+      if (!parsed) continue;
+
+      const sourcePath = join(conversationsDir, dirName);
+      const targetName = `${parsed.timestamp}_${parsed.conversationId}`;
+      const targetPath = join(conversationsDir, targetName);
+
+      if (sourcePath === targetPath) continue;
+      if (existsSync(targetPath)) continue;
+
+      try {
+        renameSync(sourcePath, targetPath);
+      } catch {
+        // Best-effort: leave the old directory in place if a single rename fails.
+      }
+    }
+  },
+};

package/src/workspace/migrations/013-repair-conversation-disk-view.ts

@@ -0,0 +1,11 @@
+import { rebuildConversationDiskViewFromDb } from "./rebuild-conversation-disk-view.js";
+import type { WorkspaceMigration } from "./types.js";
+
+export const repairConversationDiskViewMigration: WorkspaceMigration = {
+  id: "013-repair-conversation-disk-view",
+  description:
+    "Repair missing conversation disk-view folders skipped by the conversationKey creation path",
+  run(_workspaceDir: string): void {
+    rebuildConversationDiskViewFromDb();
+  },
+};

package/src/workspace/migrations/rebuild-conversation-disk-view.ts

@@ -0,0 +1,186 @@
+import {
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { join } from "node:path";
+
+import { asc, eq } from "drizzle-orm";
+
+import { resolveConversationDirectoryPaths } from "../../memory/conversation-directories.js";
+import {
+  initConversationDir,
+  syncMessageToDisk,
+  updateMetaFile,
+} from "../../memory/conversation-disk-view.js";
+import { getDb } from "../../memory/db.js";
+import { conversations, messages } from "../../memory/schema.js";
+import { getLogger } from "../../util/logger.js";
+
+const log = getLogger("workspace-migrations");
+
+function hasExpectedDiskViewArtifacts(
+  conv: { updatedAt: number },
+  dirPath: string,
+): boolean {
+  const metaPath = join(dirPath, "meta.json");
+  const messagesPath = join(dirPath, "messages.jsonl");
+  const attachDir = join(dirPath, "attachments");
+  if (
+    !existsSync(metaPath) ||
+    !existsSync(messagesPath) ||
+    !existsSync(attachDir)
+  )
+    return false;
+
+  try {
+    const existing = JSON.parse(readFileSync(metaPath, "utf-8"));
+    const expectedUpdatedAt = new Date(conv.updatedAt).toISOString();
+    return existing.updatedAt === expectedUpdatedAt;
+  } catch {
+    return false;
+  }
+}
+
+function convergeDualConversationDirsToCanonical(
+  conv: { updatedAt: number },
+  canonicalDirPath: string,
+  legacyDirPath: string,
+): void {
+  if (!existsSync(canonicalDirPath) || !existsSync(legacyDirPath)) return;
+  if (!hasExpectedDiskViewArtifacts(conv, canonicalDirPath)) return;
+  rmSync(legacyDirPath, { recursive: true, force: true });
+}
+
+function getProjectedAttachmentFilenames(messagesPath: string): Set<string> {
+  const filenames = new Set<string>();
+  if (!existsSync(messagesPath)) return filenames;
+
+  const raw = readFileSync(messagesPath, "utf-8");
+  for (const line of raw.split("\n")) {
+    if (!line.trim()) continue;
+    try {
+      const parsed = JSON.parse(line) as { attachments?: unknown };
+      if (!Array.isArray(parsed.attachments)) continue;
+      for (const attachment of parsed.attachments) {
+        if (typeof attachment === "string") {
+          filenames.add(attachment);
+        }
+      }
+    } catch {
+      // Ignore malformed lines. A later replay will rewrite them.
+    }
+  }
+
+  return filenames;
+}
+
+function pruneUnreferencedProjectedAttachments(
+  attachDir: string,
+  messagesPath: string,
+): void {
+  if (!existsSync(attachDir)) return;
+
+  const referenced = getProjectedAttachmentFilenames(messagesPath);
+  for (const entry of readdirSync(attachDir)) {
+    if (referenced.has(entry)) continue;
+    rmSync(join(attachDir, entry), { recursive: true, force: true });
+  }
+}
+
+/**
+ * Rebuild the conversation disk view for all persisted conversations.
+ *
+ * Conversations are processed by ascending createdAt so replay ordering is
+ * stable and deterministic across runs.
+ */
+export function rebuildConversationDiskViewFromDb(): void {
+  const db = getDb();
+
+  const allConversations = db
+    .select()
+    .from(conversations)
+    .orderBy(asc(conversations.createdAt))
+    .all();
+
+  const total = allConversations.length;
+  let processed = 0;
+
+  for (const conv of allConversations) {
+    const {
+      canonicalDirPath,
+      legacyDirPath,
+      resolvedDirPath: dirPath,
+    } = resolveConversationDirectoryPaths(conv.id, conv.createdAt);
+    const metaPath = join(dirPath, "meta.json");
+    const messagesPath = join(dirPath, "messages.jsonl");
+    const attachDir = join(dirPath, "attachments");
+
+    // Check if already migrated (idempotent)
+    if (existsSync(metaPath) && hasExpectedDiskViewArtifacts(conv, dirPath)) {
+      // Prefer the timestamp-first canonical directory whenever both sibling
+      // directories exist and the canonical projection is complete.
+      convergeDualConversationDirsToCanonical(
+        conv,
+        canonicalDirPath,
+        legacyDirPath,
+      );
+      processed++;
+      if (processed % 50 === 0) {
+        log.info(`Backfilled ${processed}/${total} conversations to disk`);
+      }
+      continue;
+    }
+
+    // Create dir + meta.json (initConversationDir sets updatedAt = createdAt)
+    initConversationDir(conv);
+
+    // Clear stale data from any previous interrupted run so append-only
+    // syncMessageToDisk calls below don't produce duplicates.
+    if (existsSync(messagesPath)) {
+      rmSync(messagesPath, { force: true });
+    }
+    writeFileSync(messagesPath, "");
+
+    // Preserve already materialized attachment files across repair replay.
+    // Some rows have data_base64 compacted away and only retain their
+    // conversation-scoped file_path, so removing attachments/ here would
+    // make the content unrecoverable.
+    mkdirSync(attachDir, { recursive: true });
+
+    // Query all messages for this conversation and sync each to disk
+    const convMessages = db
+      .select()
+      .from(messages)
+      .where(eq(messages.conversationId, conv.id))
+      .orderBy(asc(messages.createdAt))
+      .all();
+
+    for (const msg of convMessages) {
+      syncMessageToDisk(conv.id, msg.id, conv.createdAt);
+    }
+
+    // Write the real updatedAt only AFTER all messages are synced so the
+    // idempotency check won't skip a conversation with incomplete messages
+    // if the migration is interrupted mid-loop.
+    updateMetaFile(conv);
+    pruneUnreferencedProjectedAttachments(attachDir, messagesPath);
+    convergeDualConversationDirsToCanonical(
+      conv,
+      canonicalDirPath,
+      legacyDirPath,
+    );
+
+    processed++;
+    if (processed % 50 === 0) {
+      log.info(`Backfilled ${processed}/${total} conversations to disk`);
+    }
+  }
+
+  if (total > 0) {
+    log.info(`Backfilled ${processed}/${total} conversations to disk`);
+  }
+}

package/src/workspace/migrations/registry.ts

@@ -5,6 +5,11 @@ import { extractCollectUsageDataMigration } from "./004-extract-collect-usage-da
 import { addSendDiagnosticsMigration } from "./005-add-send-diagnostics.js";
 import { servicesConfigMigration } from "./006-services-config.js";
 import { webSearchProviderRenameMigration } from "./007-web-search-provider-rename.js";
+import { voiceTimeoutAndMaxStepsMigration } from "./008-voice-timeout-and-max-steps.js";
+import { backfillConversationDiskViewMigration } from "./009-backfill-conversation-disk-view.js";
+import { appDirRenameMigration } from "./010-app-dir-rename.js";
+import { renameConversationDiskViewDirsMigration } from "./012-rename-conversation-disk-view-dirs.js";
+import { repairConversationDiskViewMigration } from "./013-repair-conversation-disk-view.js";
 import type { WorkspaceMigration } from "./types.js";
 
 /**
@@ -19,4 +24,9 @@ export const WORKSPACE_MIGRATIONS: WorkspaceMigration[] = [
   addSendDiagnosticsMigration,
   servicesConfigMigration,
   webSearchProviderRenameMigration,
+  voiceTimeoutAndMaxStepsMigration,
+  backfillConversationDiskViewMigration,
+  appDirRenameMigration,
+  renameConversationDiskViewDirsMigration,
+  repairConversationDiskViewMigration,
 ];