@vellumai/assistant 0.5.1 → 0.5.3

package/src/workspace/migrations/{002-backfill-installation-id.ts → 011-backfill-installation-id.ts}

@@ -11,13 +11,13 @@ import { getExternalAssistantId } from "../../runtime/auth/external-assistant-id
 import type { WorkspaceMigration } from "./types.js";
 
 export const backfillInstallationIdMigration: WorkspaceMigration = {
-  id: "002-backfill-installation-id",
+  id: "011-backfill-installation-id",
   description:
     "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/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

@@ -1,10 +1,15 @@
 import { avatarRenameMigration } from "./001-avatar-rename.js";
-import { backfillInstallationIdMigration } from "./002-backfill-installation-id.js";
 import { seedDeviceIdMigration } from "./003-seed-device-id.js";
 import { extractCollectUsageDataMigration } from "./004-extract-collect-usage-data.js";
 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 { backfillInstallationIdMigration } from "./011-backfill-installation-id.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,
 ];

package/src/workspace/top-level-renderer.ts

@@ -1,5 +1,10 @@
 import type { TopLevelSnapshot } from "./top-level-scanner.js";
 
+export interface WorkspaceTopLevelRenderOptions {
+  currentConversationPath?: string | null;
+  currentConversationAttachmentsPath?: string | null;
+}
+
 /**
  * Render a workspace top-level snapshot into a compact XML-like block
  * suitable for injection into user messages.
@@ -8,11 +13,18 @@ import type { TopLevelSnapshot } from "./top-level-scanner.js";
  */
 export function renderWorkspaceTopLevelContext(
   snapshot: TopLevelSnapshot,
+  options: WorkspaceTopLevelRenderOptions = {},
 ): string {
   const lines: string[] = ["<workspace_top_level>"];
   lines.push(`Root: ${snapshot.rootPath}`);
   lines.push(`Directories: ${snapshot.directories.join(", ")}`);
   lines.push(`Files: ${snapshot.files.join(", ")}`);
+  if (options.currentConversationPath) {
+    lines.push(`Current conversation folder: ${options.currentConversationPath}`);
+  }
+  if (options.currentConversationAttachmentsPath) {
+    lines.push(`Attachment files: ${options.currentConversationAttachmentsPath}`);
+  }
   if (snapshot.truncated) {
     lines.push("(list truncated — more entries exist)");
   }