@vellumai/assistant 0.6.2 → 0.6.4

package/src/util/errors.ts

@@ -102,16 +102,24 @@ 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;
+  /**
+   * Tagged daemon-owned abort reason carried over from the AbortSignal that
+   * triggered this error. Untyped here to avoid a daemon→util import cycle;
+   * `AbortReason` from `util/abort-reasons.ts` is the only producer and
+   * `isAbortReason` is the canonical type guard for consumers.
+   */
+  public readonly abortReason?: unknown;
 
   constructor(
     message: string,
     public readonly provider: string,
     public readonly statusCode?: number,
-    options?: { cause?: unknown; retryAfterMs?: number },
+    options?: { cause?: unknown; retryAfterMs?: number; abortReason?: unknown },
   ) {
     super(message, ErrorCode.PROVIDER_ERROR, options);
     this.name = "ProviderError";
     this.retryAfterMs = options?.retryAfterMs;
+    this.abortReason = options?.abortReason;
   }
 }
 

package/src/util/platform.ts

@@ -45,13 +45,24 @@ export function normalizeAssistantId(assistantId: string): string {
 }
 
 /**
- * Compute the root ~/.vellum directory path.
+ * The daemon's per-instance root data directory. Resolution order:
  *
- * This is a simple inline computation — not a shared function — so each
- * helper is self-contained and the module has no hidden coupling to
- * env-var indirection.
+ *   1. `BASE_DATA_DIR` env var — set by the CLI when spawning the daemon
+ *      for a specific assistant (see `cli/src/lib/local.ts`). Points at the
+ *      per-assistant instanceDir; we append `.vellum` to get the daemon's
+ *      root so root-level state (PID, credentials, runtime-port, workspace)
+ *      is isolated per instance.
+ *   2. Fallback: `join(homedir(), ".vellum")`. Used when the daemon runs
+ *      outside the CLI-spawn lifecycle (containerized deployments, manual
+ *      test invocations).
+ *
+ * Docker mode relocates the workspace via `VELLUM_WORKSPACE_DIR` rather
+ * than `BASE_DATA_DIR`, so honoring `BASE_DATA_DIR` here does not affect
+ * containerized deployments.
  */
 function vellumRoot(): string {
+  const baseDataDir = process.env.BASE_DATA_DIR?.trim();
+  if (baseDataDir) return join(baseDataDir, ".vellum");
   return join(homedir(), ".vellum");
 }
 
@@ -136,39 +147,54 @@ export function isTCPEnabled(): boolean {
 
 /**
  * Returns the hostname/address for the TCP listener.
- * If iOS pairing is enabled (flag file): '0.0.0.0' (LAN-accessible).
- * Default: '127.0.0.1' (localhost only).
+ * Always binds to localhost only. iOS pairing uses the gateway
+ * relay.
  */
 export function getTCPHost(): string {
-  if (isIOSPairingEnabled()) return "0.0.0.0";
   return "127.0.0.1";
 }
 
+// Kept in sync with `cli/src/lib/environments/seeds.ts` and
+// `clients/chrome-extension/native-host/src/lockfile.ts`. Drift between
+// these three sites is caught at test time by
+// `cli/src/__tests__/env-drift.test.ts`. Fast follow: hoist the shared
+// list into a `packages/environments` package so all three sites import
+// from one place.
+const KNOWN_ENVIRONMENTS: ReadonlySet<string> = new Set([
+  "production",
+  "staging",
+  "test",
+  "dev",
+  "local",
+]);
+
 /**
- * Returns whether iOS pairing mode is enabled.
- * When enabled, the TCP listener binds to 0.0.0.0 (all interfaces)
- * instead of 127.0.0.1 (localhost only), making the daemon reachable
- * from iOS devices on the same local network.
- *
- * Checks for the presence of the flag file ~/.vellum/ios-pairing-enabled.
- * Default: false.
+ * Returns the env-scoped XDG config subdirectory name for Vellum
+ * (`vellum` in production, `vellum-<env>` otherwise). Mirrors the Swift
+ * side's `VellumPaths.configDir` and the CLI's
+ * `environments/paths.ts:getConfigDir` so the daemon resolves to the
+ * same on-disk location as every other writer of these files.
  *
- * This is separate from isTCPEnabled() — TCP can be enabled for localhost-only
- * access without exposing the daemon to the LAN.
+ * Unknown environment names fall back to production to preserve the
+ * legacy path for any unrecognized value.
  */
-export function isIOSPairingEnabled(): boolean {
-  return existsSync(join(vellumRoot(), "ios-pairing-enabled"));
+export function getXdgVellumConfigDirName(): string {
+  const raw = process.env.VELLUM_ENVIRONMENT?.trim();
+  if (!raw || raw === "production") return "vellum";
+  if (!KNOWN_ENVIRONMENTS.has(raw)) return "vellum";
+  return `vellum-${raw}`;
 }
 
 /**
- * Returns the XDG-compliant path for the platform API token
- * (~/.config/vellum/platform-token). This is the canonical location
- * shared by the CLI and desktop app.
+ * Returns the XDG-compliant path for the platform API token. Resolves to
+ * `$XDG_CONFIG_HOME/vellum/platform-token` in production and
+ * `$XDG_CONFIG_HOME/vellum-<env>/platform-token` otherwise, matching the
+ * Swift client and CLI.
  */
-function getXdgPlatformTokenPath(): string {
+export function getXdgPlatformTokenPath(): string {
   const configHome =
     process.env.XDG_CONFIG_HOME?.trim() || join(homedir(), ".config");
-  return join(configHome, "vellum", "platform-token");
+  return join(configHome, getXdgVellumConfigDirName(), "platform-token");
 }
 
 /**
@@ -202,6 +228,18 @@ export function getPidPath(): string {
   return join(vellumRoot(), "vellum.pid");
 }
 
+/**
+ * Returns the path to the runtime HTTP port file (~/.vellum/runtime-port).
+ * The daemon writes its active HTTP port here on startup so thin helpers
+ * that need to reach the runtime (e.g. the chrome-extension native messaging
+ * helper) can locate a non-default `RUNTIME_HTTP_PORT` without a manifest
+ * change. Root-level path by design — the file is read by helpers that may
+ * not know the workspace override path.
+ */
+export function getRuntimePortFilePath(): string {
+  return join(vellumRoot(), "runtime-port");
+}
+
 export function getDbPath(): string {
   return join(getDataDir(), "db", "assistant.db");
 }
@@ -328,7 +366,7 @@ export function getConversationsDir(): string {
   return join(getWorkspaceDir(), "conversations");
 }
 
-/** Returns the workspace path for a prompt file (e.g. IDENTITY.md, SOUL.md, USER.md). */
+/** Returns the workspace path for a prompt file (e.g. IDENTITY.md, SOUL.md). */
 export function getWorkspacePromptPath(file: string): string {
   return join(getWorkspaceDir(), file);
 }
@@ -388,6 +426,7 @@ export function ensureDataDir(): void {
     join(wsData, "memory"),
     join(wsData, "memory", "knowledge"),
     join(wsData, "apps"),
+    join(wsData, "attachments"),
     join(wsData, "interfaces"),
     join(wsData, "sounds"),
   ];

package/src/util/pricing.ts

@@ -21,6 +21,7 @@ const ANTHROPIC_FAST_MODE_MULTIPLIER = 6;
  */
 const PROVIDER_PRICING: Record<string, Record<string, ModelPricing>> = {
   anthropic: {
+    "claude-opus-4-7": { inputPer1M: 5, outputPer1M: 25 },
     "claude-opus-4-6": { inputPer1M: 5, outputPer1M: 25 },
     "claude-opus-4": { inputPer1M: 15, outputPer1M: 75 },
     "claude-sonnet-4": { inputPer1M: 3, outputPer1M: 15 },
@@ -55,6 +56,44 @@ const PROVIDER_PRICING: Record<string, Record<string, ModelPricing>> = {
   },
 };
 
+/**
+ * Identify a model ID as an Anthropic model — accepts both the OpenRouter
+ * prefix form (`anthropic/claude-opus-4.6`) and the bare Anthropic slug
+ * (`claude-opus-4-6`) that `response.model` sometimes carries.
+ */
+function isAnthropicModelId(model: string): boolean {
+  return model.startsWith("anthropic/") || model.startsWith("claude-");
+}
+
+/**
+ * Normalize an OpenRouter-style Anthropic model ID for lookup against the
+ * Anthropic catalog: strip the `anthropic/` prefix and convert OpenRouter's
+ * dot-separated version tokens (`claude-opus-4.6`) to the dash form Anthropic
+ * uses natively (`claude-opus-4-6`).
+ */
+function normalizeAnthropicModelId(model: string): string {
+  const bare = model.startsWith("anthropic/")
+    ? model.slice("anthropic/".length)
+    : model;
+  return bare.replace(/\./g, "-");
+}
+
+/**
+ * Whether Anthropic's pricing rules (cache-read/write multipliers, fast-mode
+ * surcharge) apply for the given provider/model. True for direct Anthropic
+ * calls and for Anthropic models routed through OpenRouter — OpenRouter
+ * proxies to Anthropic's Messages API, so the usage response carries the
+ * same cache and speed fields and is charged at Anthropic's rates.
+ */
+export function usesAnthropicPricingRules(
+  provider: string,
+  model: string,
+): boolean {
+  if (provider === "anthropic") return true;
+  if (provider === "openrouter" && isAnthropicModelId(model)) return true;
+  return false;
+}
+
 /**
  * Look up pricing for a model within a provider's catalog.
  * Tries exact match first, then longest prefix match.
@@ -147,12 +186,14 @@ function getAnthropicCacheWriteTokens(usage: PricingUsage): {
  */
 function calculateUsageCost(
   provider: string,
+  model: string,
   pricing: ModelPricing,
   usage: PricingUsage,
 ): number {
+  const useAnthropicRules = usesAnthropicPricingRules(provider, model);
   // Anthropic fast mode: 6x multiplier on base rates (cache multipliers stack on top)
   const speedMultiplier =
-    provider === "anthropic" && usage.speed === "fast"
+    useAnthropicRules && usage.speed === "fast"
       ? ANTHROPIC_FAST_MODE_MULTIPLIER
       : 1;
   const effectivePricing: ModelPricing = {
@@ -169,7 +210,7 @@ function calculateUsageCost(
     usage.outputTokens,
   );
 
-  if (provider !== "anthropic") {
+  if (!useAnthropicRules) {
     return (
       directInputCost +
       outputCost +
@@ -223,6 +264,27 @@ export function resolvePricingForUsage(
   model: string,
   usage: PricingUsage,
 ): PricingResult {
+  // Anthropic models routed through OpenRouter: look up against the Anthropic
+  // catalog using the normalized bare slug. OpenRouter bills these calls at
+  // Anthropic's rates and the underlying Messages API response includes
+  // Anthropic's cache- and speed-metadata fields.
+  if (provider === "openrouter" && isAnthropicModelId(model)) {
+    const anthropicCatalog = PROVIDER_PRICING.anthropic;
+    if (anthropicCatalog) {
+      const pricing = findPricing(
+        anthropicCatalog,
+        normalizeAnthropicModelId(model),
+      );
+      if (pricing) {
+        return {
+          estimatedCostUsd: calculateUsageCost(provider, model, pricing, usage),
+          pricingStatus: "priced",
+        };
+      }
+    }
+    return { estimatedCostUsd: null, pricingStatus: "unpriced" };
+  }
+
   const providerCatalog = PROVIDER_PRICING[provider];
   if (!providerCatalog) {
     return { estimatedCostUsd: null, pricingStatus: "unpriced" };
@@ -234,7 +296,7 @@ export function resolvePricingForUsage(
   }
 
   return {
-    estimatedCostUsd: calculateUsageCost(provider, pricing, usage),
+    estimatedCostUsd: calculateUsageCost(provider, model, pricing, usage),
     pricingStatus: "priced",
   };
 }
@@ -253,6 +315,7 @@ export function resolvePricingForUsageWithOverrides(
     return {
       estimatedCostUsd: calculateUsageCost(
         provider,
+        model,
         {
           inputPer1M: bestOverride.inputPer1M,
           outputPer1M: bestOverride.outputPer1M,

package/src/util/spawn.ts

@@ -22,7 +22,7 @@ export function spawnWithTimeout(
   timeoutMs: number,
 ): Promise<{ exitCode: number; stdout: string; stderr: string }> {
   return new Promise((resolve, reject) => {
-    // Augment PATH so Homebrew-installed tools (ffmpeg, ffprobe, whisper-cpp)
+    // Augment PATH so Homebrew-installed tools (ffmpeg, ffprobe)
     // are found even when the daemon runs as a bundled binary with minimal PATH.
     const proc = Bun.spawn(cmd, {
       stdout: "pipe",

package/src/util/truncate.ts

@@ -1,6 +1,8 @@
+import { safeStringSlice } from "./unicode.js";
+
 /** Truncate a string to `maxLen` characters, appending `suffix` if truncated. */
 export function truncate(str: string, maxLen: number, suffix = "..."): string {
   if (str.length <= maxLen) return str;
-  if (maxLen < suffix.length) return str.slice(0, maxLen);
-  return str.slice(0, maxLen - suffix.length) + suffix;
+  if (maxLen < suffix.length) return safeStringSlice(str, 0, maxLen);
+  return safeStringSlice(str, 0, maxLen - suffix.length) + suffix;
 }

package/src/util/unicode.ts

@@ -0,0 +1,201 @@
+/**
+ * UTF-16 surrogate-pair-safe string utilities.
+ *
+ * JavaScript strings are UTF-16. Code points above the BMP (emoji, many CJK
+ * characters, mathematical symbols, etc.) are stored as surrogate pairs — a
+ * high surrogate (U+D800–U+DBFF) followed by a low surrogate (U+DC00–U+DFFF).
+ * `String.prototype.slice` operates on code units, not code points, so naive
+ * slicing can split a pair and leave an orphaned surrogate. Orphaned
+ * surrogates are invalid UTF-16 and cause `JSON.stringify` output to be
+ * rejected by strict JSON parsers (including Anthropic's API).
+ */
+
+const HIGH_SURROGATE_START = 0xd800;
+const HIGH_SURROGATE_END = 0xdbff;
+const LOW_SURROGATE_START = 0xdc00;
+const LOW_SURROGATE_END = 0xdfff;
+const REPLACEMENT_CHAR = "\ufffd";
+
+function isHighSurrogate(code: number): boolean {
+  return code >= HIGH_SURROGATE_START && code <= HIGH_SURROGATE_END;
+}
+
+function isLowSurrogate(code: number): boolean {
+  return code >= LOW_SURROGATE_START && code <= LOW_SURROGATE_END;
+}
+
+/**
+ * Slice a string like `String.prototype.slice`, but never cut a UTF-16
+ * surrogate pair in half.
+ *
+ * If the character at `end - 1` is a high surrogate *and* there is more of
+ * the string beyond `end` (so cutting would actually orphan it), `end` is
+ * decremented by one.
+ *
+ * If the character at `start` is a low surrogate *and* `start > 0` (so we
+ * would be starting mid-pair), `start` is incremented by one.
+ *
+ * When `end === str.length` we do not touch a trailing high surrogate: if it
+ * was already orphaned upstream, repairing it here would silently mutate
+ * content. That is the sanitizer's job, not this function's.
+ */
+export function safeStringSlice(
+  str: string,
+  start = 0,
+  end: number = str.length,
+): string {
+  let safeStart = Math.max(0, Math.min(str.length, start));
+  let safeEnd = Math.max(safeStart, Math.min(str.length, end));
+
+  if (safeEnd < str.length && safeEnd > safeStart) {
+    const lastCode = str.charCodeAt(safeEnd - 1);
+    if (isHighSurrogate(lastCode)) {
+      safeEnd--;
+    }
+  }
+
+  if (safeStart > 0 && safeStart < str.length) {
+    const firstCode = str.charCodeAt(safeStart);
+    if (isLowSurrogate(firstCode)) {
+      safeStart++;
+      if (safeStart > safeEnd) safeEnd = safeStart;
+    }
+  }
+
+  return str.slice(safeStart, safeEnd);
+}
+
+/**
+ * Replace every orphaned UTF-16 surrogate in `str` with U+FFFD
+ * (REPLACEMENT CHARACTER).
+ *
+ * Returns the original reference if no changes were needed, so callers can
+ * check `result === input` as a cheap "nothing was stripped" signal.
+ */
+export function stripOrphanedSurrogates(str: string): string {
+  let needsFix = false;
+  for (let i = 0; i < str.length; i++) {
+    const code = str.charCodeAt(i);
+    if (isHighSurrogate(code)) {
+      const next = i + 1 < str.length ? str.charCodeAt(i + 1) : 0;
+      if (!isLowSurrogate(next)) {
+        needsFix = true;
+        break;
+      }
+      i++;
+    } else if (isLowSurrogate(code)) {
+      needsFix = true;
+      break;
+    }
+  }
+  if (!needsFix) return str;
+
+  let out = "";
+  for (let i = 0; i < str.length; i++) {
+    const code = str.charCodeAt(i);
+    if (isHighSurrogate(code)) {
+      const next = i + 1 < str.length ? str.charCodeAt(i + 1) : 0;
+      if (isLowSurrogate(next)) {
+        out += str[i] + str[i + 1];
+        i++;
+      } else {
+        out += REPLACEMENT_CHAR;
+      }
+    } else if (isLowSurrogate(code)) {
+      out += REPLACEMENT_CHAR;
+    } else {
+      out += str[i];
+    }
+  }
+  return out;
+}
+
+/**
+ * Result of a deep sanitization walk. If `changed` is false the caller should
+ * use the original reference it passed in; `value` is only meaningful when
+ * `changed` is true.
+ */
+export interface DeepSanitizeResult<T> {
+  value: T;
+  changed: boolean;
+  /** Count of string values that had at least one orphan replaced. */
+  fixedStringCount: number;
+}
+
+/**
+ * Recursively walk arrays and plain objects, replacing orphaned surrogates in
+ * every string value. Non-plain objects (class instances, Date, Buffer, Map,
+ * Set, etc.) and non-string primitives are returned unchanged.
+ *
+ * On the happy path (no orphans found anywhere in the tree) the original
+ * reference is returned verbatim — no copies are made.
+ */
+export function stripOrphanedSurrogatesDeep<T>(input: T): DeepSanitizeResult<T> {
+  let fixedStringCount = 0;
+
+  const walk = (value: unknown): { value: unknown; changed: boolean } => {
+    if (typeof value === "string") {
+      const cleaned = stripOrphanedSurrogates(value);
+      if (cleaned !== value) {
+        fixedStringCount++;
+        return { value: cleaned, changed: true };
+      }
+      return { value, changed: false };
+    }
+
+    if (Array.isArray(value)) {
+      let next: unknown[] | null = null;
+      for (let i = 0; i < value.length; i++) {
+        const result = walk(value[i]);
+        if (result.changed && next === null) {
+          next = [];
+          for (let j = 0; j < i; j++) {
+            next.push(value[j]);
+          }
+        }
+        if (next !== null) {
+          next.push(result.value);
+        }
+      }
+      return next !== null
+        ? { value: next, changed: true }
+        : { value, changed: false };
+    }
+
+    if (value != null && typeof value === "object") {
+      const proto = Object.getPrototypeOf(value);
+      if (proto !== Object.prototype && proto !== null) {
+        return { value, changed: false };
+      }
+      const source = value as Record<string, unknown>;
+      const keys = Object.keys(source);
+      let next: Record<string, unknown> | null = null;
+      for (let i = 0; i < keys.length; i++) {
+        const key = keys[i]!;
+        const result = walk(source[key]);
+        if (result.changed && next === null) {
+          next = {};
+          for (let j = 0; j < i; j++) {
+            const priorKey = keys[j]!;
+            next[priorKey] = source[priorKey];
+          }
+        }
+        if (next !== null) {
+          next[key] = result.value;
+        }
+      }
+      return next !== null
+        ? { value: next, changed: true }
+        : { value, changed: false };
+    }
+
+    return { value, changed: false };
+  };
+
+  const result = walk(input);
+  return {
+    value: result.value as T,
+    changed: result.changed,
+    fixedStringCount,
+  };
+}

package/src/version.ts

@@ -1,36 +1,31 @@
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
 
+const DEV_VERSION_SENTINEL = "0.0.0-dev";
+
+function readPackageVersion(): string | undefined {
+  try {
+    const pkgPath = join(
+      import.meta.dirname ?? __dirname,
+      "..",
+      "package.json",
+    );
+    const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+    if (pkg.version && typeof pkg.version === "string") return pkg.version;
+  } catch {
+    // package.json missing or unreadable
+  }
+  return undefined;
+}
+
 function resolveVersion(): string {
   const envVersion = process.env.APP_VERSION;
 
-  // When APP_VERSION is not set, we're in local development — return the dev
-  // sentinel so Sentry (and similar) classify the session as "development".
-  if (!envVersion) return "0.0.0-dev";
-
-  // CI sets APP_VERSION to the dev placeholder during builds; resolve it to
-  // the package.json release version so Sentry gets a meaningful release tag.
-  if (envVersion === "0.0.0-dev") {
-    try {
-      const pkgPath = join(
-        import.meta.dirname ?? __dirname,
-        "..",
-        "package.json",
-      );
-      const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
-      if (pkg.version && typeof pkg.version === "string") return pkg.version;
-    } catch {
-      // package.json missing or unreadable
-    }
-    return "0.0.0-dev";
-  }
+  if (envVersion && envVersion !== DEV_VERSION_SENTINEL) return envVersion;
 
-  return envVersion;
+  return readPackageVersion() ?? DEV_VERSION_SENTINEL;
 }
 
-// Version is embedded at compile time via --define in CI.
-// Falls back to "0.0.0-dev" for local development, or resolves the dev
-// placeholder to package.json version when explicitly set in CI.
 export const APP_VERSION: string = resolveVersion();
 
 // Commit SHA is embedded at compile time via --define in CI.

package/src/watcher/engine.ts

@@ -19,6 +19,7 @@ import {
   insertWatcherEvent,
   resetStuckWatchers,
   setWatcherConversationId,
+  skipWatcherPoll,
   updateEventDisposition,
 } from "./watcher-store.js";
 
@@ -76,6 +77,28 @@ export async function runWatchersOnce(
       continue;
     }
 
+    // Pre-poll credential gate: skip if token is irrecoverably broken.
+    // Prevents wasting API calls and burning through circuit breaker
+    // attempts on credentials that need manual reauthorization.
+    try {
+      const { checkCredentialForProvider } =
+        await import("../credential-health/credential-health-service.js");
+      const health = await checkCredentialForProvider(
+        watcher.credentialService,
+      );
+      if (
+        health &&
+        (health.status === "revoked" ||
+          health.status === "missing_token" ||
+          (health.status === "expired" && !health.canAutoRecover))
+      ) {
+        skipWatcherPoll(watcher.id, `Credential unhealthy: ${health.details}`);
+        continue;
+      }
+    } catch {
+      // Non-fatal: proceed with normal poll if health check fails
+    }
+
     try {
       const config = watcher.configJson ? JSON.parse(watcher.configJson) : {};
 

package/src/watcher/watcher-store.ts

@@ -221,6 +221,37 @@ export function completeWatcherPoll(
   db.update(watchers).set(set).where(eq(watchers.id, id)).run();
 }
 
+/**
+ * Skip a watcher poll: apply backoff to nextPollAt without incrementing
+ * consecutiveErrors. Used when a poll is skipped for a recoverable reason
+ * (e.g. credential health gate) that should NOT count toward the circuit
+ * breaker threshold.
+ */
+export function skipWatcherPoll(id: string, reason: string): void {
+  const db = getDb();
+  const watcher = db.select().from(watchers).where(eq(watchers.id, id)).get();
+  if (!watcher) return;
+
+  const now = Date.now();
+  // Use the same backoff formula but based on existing consecutiveErrors
+  // (which stays unchanged). Minimum backoff of 30s.
+  const backoff = Math.min(
+    30_000 * Math.pow(2, watcher.consecutiveErrors),
+    60 * 60 * 1000,
+  );
+
+  db.update(watchers)
+    .set({
+      status: "idle",
+      lastError: truncate(reason, 2000, ""),
+      lastPollAt: now,
+      nextPollAt: now + backoff,
+      updatedAt: now,
+    })
+    .where(eq(watchers.id, id))
+    .run();
+}
+
 /**
  * Record a poll error: increment consecutive errors, apply backoff.
  */

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

@@ -8,15 +8,21 @@ import {
 import { homedir } from "node:os";
 import { join } from "node:path";
 
-import { getDeviceIdBaseDir } from "../../util/device-id.js";
 import type { WorkspaceMigration } from "./types.js";
 
+function deviceIdBaseDir(): string {
+  const containerized =
+    process.env.IS_CONTAINERIZED === "true" ||
+    process.env.IS_CONTAINERIZED === "1";
+  return containerized ? "/home/assistant" : homedir();
+}
+
 export const seedDeviceIdMigration: WorkspaceMigration = {
   id: "003-seed-device-id",
   description:
     "Seed device.json deviceId from the most recent lockfile installationId for continuity",
   run(_workspaceDir: string): void {
-    const base = getDeviceIdBaseDir();
+    const base = deviceIdBaseDir();
     const vellumDir = join(base, ".vellum");
     const devicePath = join(vellumDir, "device.json");
 
@@ -109,7 +115,7 @@ export const seedDeviceIdMigration: WorkspaceMigration = {
     // The forward migration seeds deviceId in ~/.vellum/device.json from the
     // lockfile. Reverse by removing device.json entirely — getDeviceId() will
     // generate a fresh one on next startup if needed.
-    const base = getDeviceIdBaseDir();
+    const base = deviceIdBaseDir();
     const devicePath = join(base, ".vellum", "device.json");
     if (existsSync(devicePath)) {
       unlinkSync(devicePath);