@vellumai/assistant 0.6.3 → 0.6.4

package/src/__tests__/workspace-migration-drop-user-md.test.ts

@@ -0,0 +1,368 @@
+/**
+ * Tests for workspace migration `031-drop-user-md`.
+ *
+ * Validates the five behavioral contracts spelled out in the plan:
+ *   1. Fresh install (no guardian) — no-op.
+ *   2. Pre-017 customized USER.md, guardian has no userFile — backfill slug,
+ *      copy content into users/<slug>.md, delete USER.md.
+ *   3. Post-017 state (users/<slug>.md already populated, USER.md still on disk
+ *      as template) — migration does NOT overwrite users/<slug>.md, deletes USER.md.
+ *   4. Idempotent re-run — running twice has no additional effect.
+ *   5. Guardian with missing users/ directory — migration creates the directory.
+ *
+ * The migration imports `findGuardianForChannel`, `listGuardianChannels`,
+ * and `generateUserFileSlug` from `contacts/contact-store.js`, and calls
+ * `getDb()` to persist backfilled slugs. These tests stub the contact
+ * store and DB layer so no real DB is exercised.
+ */
+
+import {
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import {
+  afterAll,
+  afterEach,
+  beforeAll,
+  beforeEach,
+  describe,
+  expect,
+  mock,
+  test,
+} from "bun:test";
+
+// ── Mock state ────────────────────────────────────────────────────
+
+interface MockContact {
+  id: string;
+  displayName: string;
+  userFile: string | null;
+}
+
+let mockVellumGuardian: {
+  contact: MockContact;
+  channel: Record<string, unknown>;
+} | null = null;
+let mockAnyGuardian: {
+  contact: MockContact;
+  channels: Record<string, unknown>[];
+} | null = null;
+let mockSlugOverride: ((displayName: string) => string) | null = null;
+
+// Records drizzle `.update(contacts).set({userFile: ...}).where(...).run()` calls.
+let updatedUserFiles: Array<{ contactId: string; userFile: string }> = [];
+
+// ── Mock modules (must precede migration import) ──────────────────
+
+mock.module("../contacts/contact-store.js", () => ({
+  findGuardianForChannel: (channelType: string) =>
+    channelType === "vellum" ? mockVellumGuardian : null,
+  listGuardianChannels: () => mockAnyGuardian,
+  generateUserFileSlug: (displayName: string) => {
+    if (mockSlugOverride) return mockSlugOverride(displayName);
+    const base =
+      displayName
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "") || "user";
+    return `${base}.md`;
+  },
+}));
+
+// Minimal drizzle-compatible stub for the single `update` call in the
+// migration. The migration builds:
+//   db.update(contacts).set({ userFile: slug }).where(eq(contacts.id, guardian.id)).run();
+// The stub captures the payload into `updatedUserFiles` and also mutates
+// the active mock guardian in place so downstream reads observe the new slug.
+mock.module("../memory/db.js", () => ({
+  getDb: () => ({
+    update: () => ({
+      set: (values: { userFile: string }) => ({
+        where: () => ({
+          run: () => {
+            const guardian =
+              mockVellumGuardian?.contact ?? mockAnyGuardian?.contact ?? null;
+            if (guardian) {
+              guardian.userFile = values.userFile;
+              updatedUserFiles.push({
+                contactId: guardian.id,
+                userFile: values.userFile,
+              });
+            }
+          },
+        }),
+      }),
+    }),
+  }),
+}));
+
+// drizzle-orm's `eq()` is invoked by the migration; stub it out so we
+// don't need the real module loaded for unit tests.
+mock.module("drizzle-orm", () => ({
+  eq: (_col: unknown, value: unknown) => ({ col: _col, value }),
+}));
+
+// Stub the schema import so drizzle operand construction doesn't touch
+// the real sqlite schema (which pulls in the DB).
+mock.module("../memory/schema/contacts.js", () => ({
+  contacts: { id: "id", userFile: "userFile" },
+}));
+
+// Import AFTER mocks so the migration binds to the stubs above.
+import { dropUserMdMigration } from "../workspace/migrations/031-drop-user-md.js";
+
+// ── Test workspace scaffold ───────────────────────────────────────
+
+let testRoot: string;
+let workspaceDir: string;
+
+function templateContent(): string {
+  return `_ Lines starting with _ are comments - they won't appear in the system prompt
+
+# USER.md
+
+Store details about your user here. Edit freely - build this over time as you learn about them. Don't be pushy about seeking details, but when you learn something, write it down. More context makes you more useful.
+
+- Preferred name/reference:
+- Pronouns:
+- Locale:
+- Work role:
+- Goals:
+- Hobbies/fun:
+- Daily tools:
+`;
+}
+
+function customizedContent(): string {
+  return `_ Lines starting with _ are comments - they won't appear in the system prompt
+
+# USER.md
+
+- Preferred name/reference: Sidd
+- Pronouns: he/him
+- Work role: Engineer
+- Daily tools: Vellum, vim, tmux
+`;
+}
+
+beforeAll(() => {
+  testRoot = mkdtempSync(join(tmpdir(), "drop-user-md-test-"));
+});
+
+afterAll(() => {
+  rmSync(testRoot, { recursive: true, force: true });
+});
+
+beforeEach(() => {
+  workspaceDir = mkdtempSync(join(testRoot, "ws-"));
+  mockVellumGuardian = null;
+  mockAnyGuardian = null;
+  mockSlugOverride = null;
+  updatedUserFiles = [];
+});
+
+afterEach(() => {
+  rmSync(workspaceDir, { recursive: true, force: true });
+});
+
+// ── Tests ─────────────────────────────────────────────────────────
+
+describe("workspace migration 031-drop-user-md", () => {
+  test("has the correct id and description", () => {
+    expect(dropUserMdMigration.id).toBe("031-drop-user-md");
+    expect(dropUserMdMigration.description).toContain(
+      "Delete legacy workspace-root USER.md",
+    );
+  });
+
+  test("fresh install (no guardian, no USER.md) is a no-op", () => {
+    // No guardian stubbed in, no USER.md on disk.
+    dropUserMdMigration.run(workspaceDir);
+
+    expect(existsSync(join(workspaceDir, "USER.md"))).toBe(false);
+    expect(existsSync(join(workspaceDir, "users"))).toBe(false);
+    expect(updatedUserFiles).toEqual([]);
+  });
+
+  test("pre-017 customized USER.md with guardian missing userFile backfills slug and migrates content", () => {
+    // Guardian exists on the 'vellum' channel but has no userFile.
+    mockVellumGuardian = {
+      contact: {
+        id: "guardian-1",
+        displayName: "Sidd",
+        userFile: null,
+      },
+      channel: { type: "vellum" },
+    };
+
+    const userMdPath = join(workspaceDir, "USER.md");
+    const content = customizedContent();
+    writeFileSync(userMdPath, content, "utf-8");
+
+    dropUserMdMigration.run(workspaceDir);
+
+    // Backfill happened: drizzle update was called with the generated slug.
+    expect(updatedUserFiles).toHaveLength(1);
+    expect(updatedUserFiles[0].contactId).toBe("guardian-1");
+    expect(updatedUserFiles[0].userFile).toBe("sidd.md");
+
+    // Content was migrated into users/sidd.md.
+    const destPath = join(workspaceDir, "users", "sidd.md");
+    expect(existsSync(destPath)).toBe(true);
+    expect(readFileSync(destPath, "utf-8")).toBe(content);
+
+    // Legacy USER.md was deleted.
+    expect(existsSync(userMdPath)).toBe(false);
+  });
+
+  test("post-017 users/<slug>.md already populated, USER.md still on disk as template — does not overwrite dest, deletes USER.md", () => {
+    // Guardian already has a userFile from a prior 017 run.
+    mockVellumGuardian = {
+      contact: {
+        id: "guardian-2",
+        displayName: "Sidd",
+        userFile: "sidd.md",
+      },
+      channel: { type: "vellum" },
+    };
+
+    // Pre-populated persona file (post-017 state).
+    const usersDir = join(workspaceDir, "users");
+    mkdirSync(usersDir, { recursive: true });
+    const destPath = join(usersDir, "sidd.md");
+    const existingPersona = "# Sidd's Profile\n\n- Loves kayaking\n";
+    writeFileSync(destPath, existingPersona, "utf-8");
+
+    // Leftover template-shape USER.md at workspace root.
+    const userMdPath = join(workspaceDir, "USER.md");
+    writeFileSync(userMdPath, templateContent(), "utf-8");
+
+    dropUserMdMigration.run(workspaceDir);
+
+    // users/sidd.md is untouched.
+    expect(readFileSync(destPath, "utf-8")).toBe(existingPersona);
+
+    // USER.md is gone.
+    expect(existsSync(userMdPath)).toBe(false);
+
+    // No slug backfill necessary.
+    expect(updatedUserFiles).toEqual([]);
+  });
+
+  test("idempotent: second run is a no-op after the first run deleted USER.md", () => {
+    mockVellumGuardian = {
+      contact: {
+        id: "guardian-3",
+        displayName: "Alice",
+        userFile: "alice.md",
+      },
+      channel: { type: "vellum" },
+    };
+
+    const userMdPath = join(workspaceDir, "USER.md");
+    writeFileSync(userMdPath, customizedContent(), "utf-8");
+
+    // First run: migrates content and deletes USER.md.
+    dropUserMdMigration.run(workspaceDir);
+    expect(existsSync(userMdPath)).toBe(false);
+    const destPath = join(workspaceDir, "users", "alice.md");
+    expect(existsSync(destPath)).toBe(true);
+    const afterFirst = readFileSync(destPath, "utf-8");
+
+    // Second run: no USER.md remains, users/alice.md already has content,
+    // so the destination is not rewritten and USER.md is still absent.
+    dropUserMdMigration.run(workspaceDir);
+    expect(existsSync(userMdPath)).toBe(false);
+    expect(existsSync(destPath)).toBe(true);
+    expect(readFileSync(destPath, "utf-8")).toBe(afterFirst);
+  });
+
+  test("guardian exists but users/ directory is missing — migration creates the directory", () => {
+    mockVellumGuardian = {
+      contact: {
+        id: "guardian-4",
+        displayName: "Bob",
+        userFile: "bob.md",
+      },
+      channel: { type: "vellum" },
+    };
+
+    // USER.md present but no users/ dir yet.
+    const userMdPath = join(workspaceDir, "USER.md");
+    writeFileSync(userMdPath, customizedContent(), "utf-8");
+    expect(existsSync(join(workspaceDir, "users"))).toBe(false);
+
+    dropUserMdMigration.run(workspaceDir);
+
+    expect(existsSync(join(workspaceDir, "users"))).toBe(true);
+    const destPath = join(workspaceDir, "users", "bob.md");
+    expect(existsSync(destPath)).toBe(true);
+    expect(readFileSync(destPath, "utf-8")).toBe(customizedContent());
+    expect(existsSync(userMdPath)).toBe(false);
+  });
+
+  // ─── Bonus coverage for edge cases ───────────────────────────────
+
+  test("falls back to listGuardianChannels when no vellum-channel guardian exists", () => {
+    mockVellumGuardian = null;
+    mockAnyGuardian = {
+      contact: {
+        id: "guardian-5",
+        displayName: "Carol",
+        userFile: "carol.md",
+      },
+      channels: [{ type: "telegram" }],
+    };
+
+    const userMdPath = join(workspaceDir, "USER.md");
+    writeFileSync(userMdPath, customizedContent(), "utf-8");
+
+    dropUserMdMigration.run(workspaceDir);
+
+    const destPath = join(workspaceDir, "users", "carol.md");
+    expect(existsSync(destPath)).toBe(true);
+    expect(readFileSync(destPath, "utf-8")).toBe(customizedContent());
+    expect(existsSync(userMdPath)).toBe(false);
+  });
+
+  test("template-shaped USER.md with no destination file — seeds scaffold and deletes USER.md", () => {
+    mockVellumGuardian = {
+      contact: {
+        id: "guardian-6",
+        displayName: "Dana",
+        userFile: "dana.md",
+      },
+      channel: { type: "vellum" },
+    };
+
+    const userMdPath = join(workspaceDir, "USER.md");
+    writeFileSync(userMdPath, templateContent(), "utf-8");
+
+    dropUserMdMigration.run(workspaceDir);
+
+    // USER.md is gone.
+    expect(existsSync(userMdPath)).toBe(false);
+
+    // The destination was scaffolded with the guardian persona template
+    // (parity with ensureGuardianPersonaFile for new installs).
+    const destPath = join(workspaceDir, "users", "dana.md");
+    expect(existsSync(destPath)).toBe(true);
+    const content = readFileSync(destPath, "utf-8");
+    expect(content).toContain("# User Profile");
+    expect(content).toContain("Preferred name/reference:");
+    // Not the legacy template header.
+    expect(content).not.toContain("# USER.md");
+  });
+
+  test("down() is a no-op (deletion is irreversible)", () => {
+    // Should not throw.
+    dropUserMdMigration.down(workspaceDir);
+    expect(existsSync(join(workspaceDir, "USER.md"))).toBe(false);
+  });
+});

package/src/__tests__/workspace-migration-meets.test.ts

@@ -0,0 +1,244 @@
+/**
+ * Tests for workspace migration `037-create-meets-dir`.
+ *
+ * The migration creates `<workspace>/meets/` (if missing) and seeds a
+ * `.keep` sentinel file. It must be idempotent and must not touch other
+ * workspace files.
+ */
+
+import {
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  readdirSync,
+  readFileSync,
+  rmSync,
+  statSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+
+import { createMeetsDirMigration } from "../workspace/migrations/037-create-meets-dir.js";
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+let workspaceDir: string;
+
+beforeEach(() => {
+  workspaceDir = mkdtempSync(join(tmpdir(), "vellum-migration-037-test-"));
+});
+
+afterEach(() => {
+  if (existsSync(workspaceDir)) {
+    rmSync(workspaceDir, { recursive: true, force: true });
+  }
+});
+
+/**
+ * Snapshot the (relative path -> mtimeMs, content) for every file inside a
+ * directory so we can assert a migration did not touch it.
+ */
+function snapshotTree(
+  root: string,
+): Record<string, { mtimeMs: number; content: string }> {
+  const out: Record<string, { mtimeMs: number; content: string }> = {};
+  function walk(dir: string): void {
+    if (!existsSync(dir)) return;
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+      const abs = join(dir, entry.name);
+      if (entry.isDirectory()) {
+        walk(abs);
+      } else if (entry.isFile()) {
+        const rel = abs.slice(root.length + 1);
+        out[rel] = {
+          mtimeMs: statSync(abs).mtimeMs,
+          content: readFileSync(abs, "utf-8"),
+        };
+      }
+    }
+  }
+  walk(root);
+  return out;
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe("037-create-meets-dir migration", () => {
+  test("has correct id and description", () => {
+    expect(createMeetsDirMigration.id).toBe("037-create-meets-dir");
+    expect(createMeetsDirMigration.description).toContain("meets/");
+  });
+
+  test("creates meets/ with .keep sentinel file on a fresh workspace", () => {
+    createMeetsDirMigration.run(workspaceDir);
+
+    const meetsDir = join(workspaceDir, "meets");
+    expect(existsSync(meetsDir)).toBe(true);
+    expect(statSync(meetsDir).isDirectory()).toBe(true);
+
+    const keepPath = join(meetsDir, ".keep");
+    expect(existsSync(keepPath)).toBe(true);
+    expect(statSync(keepPath).isFile()).toBe(true);
+  });
+
+  test("is idempotent — running twice does not error and does not overwrite .keep", () => {
+    createMeetsDirMigration.run(workspaceDir);
+
+    const keepPath = join(workspaceDir, "meets", ".keep");
+    expect(existsSync(keepPath)).toBe(true);
+
+    const firstContent = readFileSync(keepPath, "utf-8");
+    const firstMtime = statSync(keepPath).mtimeMs;
+
+    // Second run — should not throw, should not rewrite the .keep file.
+    createMeetsDirMigration.run(workspaceDir);
+
+    expect(existsSync(keepPath)).toBe(true);
+    expect(readFileSync(keepPath, "utf-8")).toBe(firstContent);
+    expect(statSync(keepPath).mtimeMs).toBe(firstMtime);
+  });
+
+  test("does not error when meets/ already exists with user content", () => {
+    // Simulate a pre-existing meets/ directory with a user meeting inside.
+    const meetsDir = join(workspaceDir, "meets");
+    const meetingDir = join(meetsDir, "meeting-abc");
+    mkdirSync(meetingDir, { recursive: true });
+    writeFileSync(join(meetingDir, "meta.json"), "{}", "utf-8");
+
+    createMeetsDirMigration.run(workspaceDir);
+
+    // Pre-existing content is preserved.
+    expect(existsSync(join(meetingDir, "meta.json"))).toBe(true);
+    expect(readFileSync(join(meetingDir, "meta.json"), "utf-8")).toBe("{}");
+
+    // .keep sentinel was added at the meets/ root.
+    expect(existsSync(join(meetsDir, ".keep"))).toBe(true);
+  });
+
+  test("does not overwrite a user-customized .keep file", () => {
+    const meetsDir = join(workspaceDir, "meets");
+    mkdirSync(meetsDir, { recursive: true });
+    const keepPath = join(meetsDir, ".keep");
+    const customContent = "# my notes about meets/\n";
+    writeFileSync(keepPath, customContent, "utf-8");
+
+    createMeetsDirMigration.run(workspaceDir);
+
+    expect(readFileSync(keepPath, "utf-8")).toBe(customContent);
+  });
+
+  test("does not touch other workspace files", () => {
+    // Pre-populate unrelated workspace files.
+    writeFileSync(
+      join(workspaceDir, "config.json"),
+      JSON.stringify({ hello: "world" }, null, 2),
+      "utf-8",
+    );
+    mkdirSync(join(workspaceDir, "users"), { recursive: true });
+    writeFileSync(
+      join(workspaceDir, "users", "guardian.md"),
+      "# Guardian\n",
+      "utf-8",
+    );
+    mkdirSync(join(workspaceDir, "pkb"), { recursive: true });
+    writeFileSync(
+      join(workspaceDir, "pkb", "INDEX.md"),
+      "# Knowledge Base\n",
+      "utf-8",
+    );
+
+    const before = snapshotTree(workspaceDir);
+
+    createMeetsDirMigration.run(workspaceDir);
+
+    const after = snapshotTree(workspaceDir);
+
+    // Everything that existed before should still exist with identical
+    // content and mtime (nothing touched).
+    for (const [rel, prev] of Object.entries(before)) {
+      expect(after[rel]).toBeDefined();
+      expect(after[rel].content).toBe(prev.content);
+      expect(after[rel].mtimeMs).toBe(prev.mtimeMs);
+    }
+
+    // Only the .keep under meets/ should be new.
+    const added = Object.keys(after).filter((rel) => !(rel in before));
+    expect(added).toEqual([join("meets", ".keep")]);
+  });
+
+  test("second run on a populated meets/ leaves user content untouched", () => {
+    createMeetsDirMigration.run(workspaceDir);
+
+    const meetsDir = join(workspaceDir, "meets");
+    const meetingDir = join(meetsDir, "meeting-xyz");
+    mkdirSync(meetingDir, { recursive: true });
+    const transcriptPath = join(meetingDir, "transcript.jsonl");
+    writeFileSync(
+      transcriptPath,
+      '{"t":0,"text":"hello"}\n',
+      "utf-8",
+    );
+    const before = snapshotTree(workspaceDir);
+
+    createMeetsDirMigration.run(workspaceDir);
+
+    const after = snapshotTree(workspaceDir);
+    expect(Object.keys(after).sort()).toEqual(Object.keys(before).sort());
+    for (const [rel, prev] of Object.entries(before)) {
+      expect(after[rel].content).toBe(prev.content);
+      expect(after[rel].mtimeMs).toBe(prev.mtimeMs);
+    }
+  });
+
+  // ─── down() ─────────────────────────────────────────────────────────────
+
+  describe("down()", () => {
+    test("removes seeded .keep and empty meets/ directory after a forward run", () => {
+      createMeetsDirMigration.run(workspaceDir);
+      expect(existsSync(join(workspaceDir, "meets", ".keep"))).toBe(true);
+
+      createMeetsDirMigration.down(workspaceDir);
+
+      expect(existsSync(join(workspaceDir, "meets", ".keep"))).toBe(false);
+      expect(existsSync(join(workspaceDir, "meets"))).toBe(false);
+    });
+
+    test("preserves user-created meeting content on down()", () => {
+      createMeetsDirMigration.run(workspaceDir);
+
+      const meetsDir = join(workspaceDir, "meets");
+      const meetingDir = join(meetsDir, "meeting-abc");
+      mkdirSync(meetingDir, { recursive: true });
+      writeFileSync(join(meetingDir, "meta.json"), "{}", "utf-8");
+
+      createMeetsDirMigration.down(workspaceDir);
+
+      // .keep is removed but user content and the meets/ dir itself remain
+      // since the directory is non-empty.
+      expect(existsSync(join(meetsDir, ".keep"))).toBe(false);
+      expect(existsSync(meetsDir)).toBe(true);
+      expect(existsSync(join(meetingDir, "meta.json"))).toBe(true);
+    });
+
+    test("idempotent — down() twice does not throw", () => {
+      createMeetsDirMigration.run(workspaceDir);
+      createMeetsDirMigration.down(workspaceDir);
+      // Second call — should not throw.
+      createMeetsDirMigration.down(workspaceDir);
+      expect(existsSync(join(workspaceDir, "meets"))).toBe(false);
+    });
+
+    test("no-op when meets/ does not exist", () => {
+      expect(existsSync(join(workspaceDir, "meets"))).toBe(false);
+      createMeetsDirMigration.down(workspaceDir);
+      // Should not throw and should not create anything.
+      expect(existsSync(join(workspaceDir, "meets"))).toBe(false);
+    });
+  });
+});

package/src/__tests__/workspace-migration-seed-device-id.test.ts

@@ -11,7 +11,6 @@ const writeFileSyncFn = mock(
 );
 const mkdirSyncFn = mock((_path: string, _opts?: object) => {});
 const homedirFn = mock((): string => "/mock-home");
-const getDeviceIdBaseDirFn = mock((): string => "/mock-home");
 
 // ---------------------------------------------------------------------------
 // Mock modules — before importing module under test
@@ -28,10 +27,6 @@ mock.module("node:os", () => ({
   homedir: homedirFn,
 }));
 
-mock.module("../util/device-id.js", () => ({
-  getDeviceIdBaseDir: getDeviceIdBaseDirFn,
-}));
-
 // Import after mocking
 import { seedDeviceIdMigration } from "../workspace/migrations/003-seed-device-id.js";
 
@@ -69,7 +64,7 @@ describe("003-seed-device-id migration", () => {
     writeFileSyncFn.mockClear();
     mkdirSyncFn.mockClear();
     homedirFn.mockReturnValue("/mock-home");
-    getDeviceIdBaseDirFn.mockReturnValue("/mock-home");
+    delete process.env.IS_CONTAINERIZED;
   });
 
   test("no-op when device.json already has a deviceId", () => {
@@ -271,14 +266,13 @@ describe("003-seed-device-id migration", () => {
     expect(parsed.deviceId).toBe("install-legacy");
   });
 
-  test("reads lockfile from homedir even when getDeviceIdBaseDir differs", () => {
-    const customBase = "/custom-base";
-    getDeviceIdBaseDirFn.mockReturnValue(customBase);
+  test("containerized: writes device.json under /home/assistant while reading lockfile from homedir", () => {
+    process.env.IS_CONTAINERIZED = "true";
     homedirFn.mockReturnValue("/mock-home");
 
-    const customDevicePath = `${customBase}/.vellum/device.json`;
+    const containerDevicePath = "/home/assistant/.vellum/device.json";
 
-    // Lockfile is at homedir, NOT at customBase
+    // Lockfile is at homedir, NOT under /home/assistant
     existsSyncFn.mockImplementation((path: string) => path === LOCK_PATH);
     readFileSyncFn.mockImplementation((path: string, _enc: string) => {
       if (path === LOCK_PATH) {
@@ -301,23 +295,23 @@ describe("003-seed-device-id migration", () => {
       string,
       object,
     ];
-    // device.json is written under getDeviceIdBaseDir, not homedir
-    expect(path).toBe(customDevicePath);
+    expect(path).toBe(containerDevicePath);
     const parsed = JSON.parse(data);
     expect(parsed.deviceId).toBe("install-custom");
   });
 
-  test("ignores lockfile under getDeviceIdBaseDir when it differs from homedir", () => {
-    const customBase = "/custom-base";
-    getDeviceIdBaseDirFn.mockReturnValue(customBase);
+  test("containerized: ignores lockfile under /home/assistant", () => {
+    process.env.IS_CONTAINERIZED = "true";
     homedirFn.mockReturnValue("/mock-home");
 
-    // Only a lockfile under customBase exists — should be ignored since
+    // Only a lockfile under /home/assistant exists — should be ignored since
     // the migration always reads the lockfile from homedir().
-    const customLockPath = `${customBase}/.vellum.lock.json`;
-    existsSyncFn.mockImplementation((path: string) => path === customLockPath);
+    const containerLockPath = "/home/assistant/.vellum.lock.json";
+    existsSyncFn.mockImplementation(
+      (path: string) => path === containerLockPath,
+    );
     readFileSyncFn.mockImplementation((path: string, _enc: string) => {
-      if (path === customLockPath) {
+      if (path === containerLockPath) {
         return makeLockfile([
           {
             name: "custom",