@vellumai/assistant 0.7.1 → 0.7.3

package/src/tools/tool-approval-handler.ts

@@ -13,12 +13,13 @@ import { getLogger } from "../util/logger.js";
 import { getAllTools, getTool } from "./registry.js";
 import { isSideEffectTool } from "./side-effects.js";
 import { summarizeToolInput } from "./tool-input-summary.js";
-import type {
-  ExecutionTarget,
-  Tool,
-  ToolContext,
-  ToolExecutionResult,
-  ToolLifecycleEvent,
+import {
+  type ExecutionTarget,
+  isDiskPressureCleanupToolName,
+  type Tool,
+  type ToolContext,
+  type ToolExecutionResult,
+  type ToolLifecycleEvent,
 } from "./types.js";
 import { enforceVerificationControlPlanePolicy } from "./verification-control-plane-policy.js";
 
@@ -292,11 +293,7 @@ export class ToolApprovalHandler {
       executionTarget,
     );
 
-    if (
-      isUntrustedTrustClass(context.trustClass) &&
-      guardianApprovalRequired &&
-      context.trustClass !== "trusted_contact"
-    ) {
+    if (isUntrustedTrustClass(context.trustClass) && guardianApprovalRequired) {
       const inputDigest = computeToolApprovalDigest(name, input);
       needsGrantConsumption = true;
       deferredConsumeParams = {
@@ -313,6 +310,30 @@ export class ToolApprovalHandler {
       };
     }
 
+    if (
+      context.diskPressureCleanupModeActive === true &&
+      !isDiskPressureCleanupToolName(name)
+    ) {
+      const msg = `Tool "${name}" is not available during disk pressure cleanup mode.`;
+      const durationMs = Date.now() - startTime;
+      emitLifecycleEvent({
+        type: "error",
+        toolName: name,
+        executionTarget,
+        input,
+        workingDir: context.workingDir,
+        conversationId: context.conversationId,
+        requestId: context.requestId,
+        riskLevel,
+        decision: "error",
+        durationMs,
+        errorMessage: msg,
+        isExpected: true,
+        errorCategory: "tool_failure",
+      });
+      return { allowed: false, result: { content: msg, isError: true } };
+    }
+
     // Gate tools not active for the current turn
     if (context.allowedToolNames && !context.allowedToolNames.has(name)) {
       const msg = `Tool "${name}" is not currently active. Load the skill that provides this tool first.`;

package/src/tools/types.ts

@@ -18,6 +18,20 @@ import type { SecretPromptResult } from "../permissions/secret-prompter.js";
 import type { ContentBlock } from "../providers/types.js";
 import type { TrustClass } from "../runtime/actor-trust-resolver.js";
 
+export const DISK_PRESSURE_CLEANUP_TOOL_NAMES: ReadonlySet<string> = new Set([
+  "bash",
+  "host_bash",
+  "file_read",
+  "file_list",
+  "host_file_read",
+  "background_tool_list",
+  "background_tool_cancel",
+]);
+
+export function isDiskPressureCleanupToolName(name: string): boolean {
+  return DISK_PRESSURE_CLEANUP_TOOL_NAMES.has(name);
+}
+
 // ---------------------------------------------------------------------------
 // Re-exports + concrete overlays for types that live in
 // @vellumai/skill-host-contracts.
@@ -138,6 +152,10 @@ export interface ToolExecutedEvent {
   riskLevel: string;
   /** ID of the trust rule that matched this invocation (if any). */
   matchedTrustRuleId?: string;
+  /** How the approval decision was reached. Copied from PermissionDecision for analytics consumers. */
+  approvalMode?: string;
+  /** Why the approval decision was reached (stable enum). Copied from PermissionDecision for analytics consumers. */
+  approvalReason?: string;
   decision: string;
   durationMs: number;
   result: ToolExecutionResult;
@@ -173,6 +191,8 @@ export interface ToolContext {
   proxyToolResolver?: ProxyToolResolver;
   /** When set, only tools in this set may execute. Tools outside the set are blocked with an error. */
   allowedToolNames?: Set<string>;
+  /** True when this turn is restricted to storage cleanup-safe tools. */
+  diskPressureCleanupModeActive?: boolean;
   /** Prompt the user for a secret value via native SecureField UI. */
   requestSecret?: (params: {
     service: string;
@@ -188,8 +208,6 @@ export interface ToolContext {
   sendToClient?: (msg: { type: string; [key: string]: unknown }) => void;
   /** True when an interactive client is connected (not just a no-op callback). */
   isInteractive?: boolean;
-  /** Memory scope ID from the conversation's memory policy, so memory tools can target the correct scope. */
-  memoryScopeId?: string;
   /** When true, tools with side effects should always prompt for confirmation. */
   forcePromptSideEffects?: boolean;
   /**
@@ -264,6 +282,14 @@ export interface ToolContext {
    * `executeSubagentSpawn` in tools/subagent/spawn.ts.
    */
   overrideProfile?: string;
+  /**
+   * Canonical principal ID of the actor on whose behalf this tool invocation
+   * is running. Sourced from `conversation.trustContext.guardianPrincipalId`.
+   * Used by host proxies to bind cross-client targeted execution to the same
+   * authenticated user identity. May be undefined for legacy/internal flows
+   * with no resolved actor identity.
+   */
+  sourceActorPrincipalId?: string;
 }
 
 export interface Tool {

package/src/tts/provider-catalog.ts

@@ -13,8 +13,6 @@
 
 import type { TtsCallMode, TtsProviderId } from "./types.js";
 
-export type { TtsCallMode } from "./types.js";
-
 // ---------------------------------------------------------------------------
 // Catalog entry model
 // ---------------------------------------------------------------------------
@@ -22,7 +20,7 @@ export type { TtsCallMode } from "./types.js";
 /**
  * Metadata about a secret (API key / credential) required by a provider.
  */
-export interface TtsProviderSecretRequirement {
+interface TtsProviderSecretRequirement {
   /**
    * The key used to retrieve this secret from the secure credential store.
    *
@@ -49,7 +47,7 @@ export interface TtsProviderSecretRequirement {
  * These describe static, provider-wide traits — they do not change based
  * on runtime configuration or per-request parameters.
  */
-export interface TtsProviderCatalogCapabilities {
+interface TtsProviderCatalogCapabilities {
   /** Whether the provider supports chunk-level streaming synthesis. */
   readonly supportsStreaming: boolean;
 
@@ -64,7 +62,7 @@ export interface TtsProviderCatalogCapabilities {
  * metadata level — identity, display name, telephony call mode,
  * capabilities, and secret requirements.
  */
-export interface TtsProviderCatalogEntry {
+interface TtsProviderCatalogEntry {
   /** Unique provider identifier matching {@link TtsProviderId}. */
   readonly id: TtsProviderId;
 

package/src/usage/pricing.ts

@@ -13,7 +13,7 @@ import type {
 
 const log = getLogger("usage-pricing");
 
-export function normalizeTokenCount(value: number | null | undefined): number {
+function normalizeTokenCount(value: number | null | undefined): number {
   if (typeof value !== "number" || !Number.isFinite(value)) return 0;
   return Math.max(value, 0);
 }

package/src/util/disk-usage.ts

@@ -0,0 +1,138 @@
+import { spawnSync } from "node:child_process";
+import { existsSync, statfsSync } from "node:fs";
+
+import { getMinikubeStorageSize } from "../config/env-registry.js";
+import { getWorkspaceDir } from "./platform.js";
+
+export interface DiskUsageInfo {
+  path: string;
+  totalMb: number;
+  usedMb: number;
+  freeMb: number;
+}
+
+/**
+ * Measure the on-disk usage of one or more directory paths using `du -sb`.
+ * Returns the sum of all paths in bytes, or null on failure.
+ */
+function getDirectorySizeBytes(paths: string[]): number | null {
+  try {
+    const existing = paths.filter((p) => existsSync(p));
+    if (existing.length === 0) return null;
+    const result = spawnSync("du", ["-sb", ...existing], {
+      encoding: "utf-8",
+      timeout: 30_000,
+    });
+    if (result.status !== 0) return null;
+    let total = 0;
+    for (const line of result.stdout.trim().split("\n")) {
+      const size = parseInt(line.split("\t")[0], 10);
+      if (!isNaN(size) && size > 0) total += size;
+    }
+    return total > 0 ? total : null;
+  } catch {
+    return null;
+  }
+}
+
+const DU_CACHE_TTL_MS = 60_000;
+let duCacheValue: number | null = null;
+let duCacheTime = 0;
+let duCachePaths: string | null = null;
+
+function getCachedDirectorySizeBytes(paths: string[]): number | null {
+  const key = paths.join("\0");
+  const now = Date.now();
+  if (duCachePaths === key && now - duCacheTime < DU_CACHE_TTL_MS) {
+    return duCacheValue;
+  }
+  duCacheValue = getDirectorySizeBytes(paths);
+  duCacheTime = now;
+  duCachePaths = key;
+  return duCacheValue;
+}
+
+export function __resetDiskUsageCacheForTests(): void {
+  duCacheValue = null;
+  duCacheTime = 0;
+  duCachePaths = null;
+}
+
+export function getDiskUsageInfo(): DiskUsageInfo | null {
+  try {
+    const wsDir = getWorkspaceDir();
+    const diskPath = existsSync(wsDir) ? wsDir : "/";
+    const stats = statfsSync(diskPath);
+    const fsTotalBytes = stats.bsize * stats.blocks;
+    const fsFreeBytes = stats.bsize * stats.bavail;
+    const bytesToMb = (b: number) =>
+      Math.round((b / (1024 * 1024)) * 100) / 100;
+
+    // Minikube mode: the platform passes the PVC storage size so we can
+    // report accurate capacity. On hostPath-backed PVCs statfsSync reports
+    // the host's entire filesystem rather than the PVC. Detect this by
+    // comparing filesystem size against PVC size — if the filesystem is
+    // larger, measure actual directory usage with `du` instead.
+    const storageSizeRaw = getMinikubeStorageSize();
+    if (storageSizeRaw) {
+      const pvcTotalBytes = parseK8sMemoryBytes(storageSizeRaw);
+      if (pvcTotalBytes !== null && fsTotalBytes > pvcTotalBytes * 1.1) {
+        const volumePaths = [diskPath];
+        if (diskPath !== "/data" && existsSync("/data")) {
+          volumePaths.push("/data");
+        }
+        const usedBytes = getCachedDirectorySizeBytes(volumePaths);
+        if (usedBytes !== null) {
+          return {
+            path: diskPath,
+            totalMb: bytesToMb(pvcTotalBytes),
+            usedMb: bytesToMb(usedBytes),
+            freeMb: bytesToMb(Math.max(0, pvcTotalBytes - usedBytes)),
+          };
+        }
+      }
+    }
+
+    return {
+      path: diskPath,
+      totalMb: bytesToMb(fsTotalBytes),
+      usedMb: bytesToMb(fsTotalBytes - fsFreeBytes),
+      freeMb: bytesToMb(fsFreeBytes),
+    };
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Parse a Kubernetes-style memory string (e.g. "3Gi", "512Mi", "1G") into bytes.
+ * Returns null if the value is not a recognized format.
+ */
+export function parseK8sMemoryBytes(value: string): number | null {
+  const match = value
+    .trim()
+    .match(/^(\d+(?:\.\d+)?)\s*(Ki|Mi|Gi|Ti|Pi|Ei|k|M|G|T|P|E|m)?$/);
+  if (!match) return null;
+  const num = parseFloat(match[1]);
+  const unit = match[2] ?? "";
+  const multipliers: Record<string, number> = {
+    "": 1,
+    m: 1e-3,
+    k: 1e3,
+    M: 1e6,
+    G: 1e9,
+    T: 1e12,
+    P: 1e15,
+    E: 1e18,
+    Ki: 1024,
+    Mi: 1024 ** 2,
+    Gi: 1024 ** 3,
+    Ti: 1024 ** 4,
+    Pi: 1024 ** 5,
+    Ei: 1024 ** 6,
+  };
+  const mult = multipliers[unit];
+  if (mult === undefined) return null;
+  const bytes = Math.round(num * mult);
+  return bytes > 0 ? bytes : null;
+}

package/src/util/platform.ts

@@ -7,14 +7,25 @@ import { getWorkspaceDirOverride } from "../config/env-registry.js";
 /**
  * The daemon's root data directory (`~/.vellum`).
  *
- * Multi-instance path relocation is handled by the CLI when spawning the
- * daemon (via `VELLUM_WORKSPACE_DIR` and `GATEWAY_SECURITY_DIR`); the
- * assistant itself never reads an env var for this.
+ * Used as a fallback when `VELLUM_WORKSPACE_DIR` is not set, and as a
+ * stable constant for paths (like `.env`) that intentionally live at the
+ * host home directory regardless of workspace relocation.
  */
 const VELLUM_ROOT = join(homedir(), ".vellum");
 
-/** Returns the daemon's root data directory (`~/.vellum`). */
+/**
+ * Returns the Vellum root directory.
+ *
+ * Resolution order (mirrors workspace/migrations/utils.ts):
+ * 1. Parent of VELLUM_WORKSPACE_DIR — e.g. /data/.vellum/workspace → /data/.vellum
+ * 2. If that parent is "/" (workspace at top level), fall back to ~/.vellum
+ */
 export function vellumRoot(): string {
+  const override = getWorkspaceDirOverride();
+  if (override) {
+    const parent = dirname(override);
+    if (parent !== "/") return parent;
+  }
   return VELLUM_ROOT;
 }
 
@@ -160,17 +171,16 @@ export function getHistoryPath(): string {
 }
 
 /**
- * Returns the protected directory (~/.vellum/protected). Security-sensitive
- * files — trust rules, encrypted credential store, signing keys, feature-flag
- * overrides, device approval lists — live here.
+ * Returns the protected directory. Security-sensitive files — trust rules,
+ * encrypted credential store, signing keys, feature-flag overrides, device
+ * approval lists — live here.
  *
  * This directory is:
- * - Outside the workspace
  * - Outside the sandbox write boundary (tools cannot modify it)
  * - Skipped in containerized mode (credentials via CES, trust via gateway)
  */
 export function getProtectedDir(): string {
-  return join(VELLUM_ROOT, "protected");
+  return join(vellumRoot(), "protected");
 }
 
 /** Returns ~/.vellum/workspace/signals — the directory for IPC signal files. */
@@ -204,7 +214,7 @@ export function getBinDir(): string {
 
 /** Returns the path to the dot-env file (~/.vellum/.env). Stays at root because it contains secrets. */
 export function getDotEnvPath(): string {
-  return join(VELLUM_ROOT, ".env");
+  return join(vellumRoot(), ".env");
 }
 
 /** Returns the path to the embed-worker PID file (~/.vellum/workspace/embed-worker.pid). */
@@ -368,7 +378,7 @@ export function getBundledBunPath(): string | undefined {
 }
 
 export function ensureDataDir(): void {
-  const root = VELLUM_ROOT;
+  const root = vellumRoot();
   const workspace = getWorkspaceDir();
   const wsData = join(workspace, "data");
   const dirs = [

package/src/util/process-liveness.ts

@@ -0,0 +1,26 @@
+/**
+ * Cross-process liveness probe shared by file-locking helpers.
+ *
+ * Uses `kill(pid, 0)`, which sends no signal but probes the OS for whether a
+ * process exists and whether the caller has permission to signal it. Returns
+ * `false` for obviously invalid PIDs and for any error indicating the process
+ * is gone (most commonly ESRCH). Returns `true` for ESRCH-negative results
+ * (process exists) and for EPERM (process exists but is owned by another user
+ * — still alive, still must not be taken over).
+ */
+
+import { kill } from "node:process";
+
+export function isProcessAlive(pid: number): boolean {
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  try {
+    kill(pid, 0);
+    return true;
+  } catch (err) {
+    const code = (err as NodeJS.ErrnoException).code;
+    // EPERM means the PID exists but we cannot signal it — treat as alive so
+    // we don't accidentally take over another user's lock.
+    if (code === "EPERM") return true;
+    return false;
+  }
+}

package/src/workspace/hatched-date.ts

@@ -0,0 +1,86 @@
+import { mkdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+import { getDataDir } from "../util/platform.js";
+
+const HATCHED_SIDECAR_FILENAME = "hatched.json";
+
+export function getHatchedSidecarPath(): string {
+  return join(getDataDir(), HATCHED_SIDECAR_FILENAME);
+}
+
+function normalizeHatchedAt(value: unknown): string | undefined {
+  if (typeof value !== "string") return undefined;
+
+  const parsedTime = Date.parse(value);
+  if (isNaN(parsedTime) || parsedTime <= 0) return undefined;
+
+  return new Date(parsedTime).toISOString();
+}
+
+export function readHatchedAtSidecar(): string | undefined {
+  try {
+    const parsed = JSON.parse(
+      readFileSync(getHatchedSidecarPath(), "utf-8"),
+    ) as { hatchedAt?: unknown };
+    return normalizeHatchedAt(parsed.hatchedAt);
+  } catch {
+    return undefined;
+  }
+}
+
+export function writeHatchedAtSidecar(hatchedAt: string): void {
+  const normalized = normalizeHatchedAt(hatchedAt);
+  if (!normalized) return;
+
+  try {
+    mkdirSync(getDataDir(), { recursive: true });
+    writeFileSync(
+      getHatchedSidecarPath(),
+      JSON.stringify({ hatchedAt: normalized }, null, 2),
+      "utf-8",
+    );
+  } catch {
+    // Best-effort stability; callers still return a valid timestamp.
+  }
+}
+
+export function selectHatchedAtFromStats(stats: {
+  birthtime: Date;
+  mtime: Date;
+}): Date | undefined {
+  const candidates = [stats.birthtime, stats.mtime];
+  return candidates.find((candidate) => candidate.getTime() > 0);
+}
+
+function readIdentityFileHatchedAt(identityPath: string): string | undefined {
+  try {
+    return selectHatchedAtFromStats(statSync(identityPath))?.toISOString();
+  } catch {
+    return undefined;
+  }
+}
+
+export function resolveHatchedAtReadOnly(
+  identityPath: string,
+  now: Date = new Date(),
+): string {
+  return (
+    readHatchedAtSidecar() ??
+    readIdentityFileHatchedAt(identityPath) ??
+    now.toISOString()
+  );
+}
+
+export function resolveAndPersistHatchedAt(
+  identityPath: string,
+  now: Date = new Date(),
+): string {
+  const sidecarHatchedAt = readHatchedAtSidecar();
+  if (sidecarHatchedAt) return sidecarHatchedAt;
+
+  const hatchedAt =
+    readIdentityFileHatchedAt(identityPath) ?? now.toISOString();
+  writeHatchedAtSidecar(hatchedAt);
+  return hatchedAt;
+}

package/src/workspace/heartbeat-service.ts

@@ -1,3 +1,8 @@
+import {
+  checkDiskPressureBackgroundGate,
+  diskPressureBackgroundSkipLogFields,
+  shouldLogDiskPressureBackgroundSkip,
+} from "../daemon/disk-pressure-background-gate.js";
 import { getLogger } from "../util/logger.js";
 import { getEnrichmentService } from "./commit-message-enrichment-service.js";
 import {
@@ -137,6 +142,20 @@ export class WorkspaceHeartbeatService {
       return { checked: 0, committed: 0, skipped: 0, failed: 0 };
     }
 
+    const diskPressureGate = checkDiskPressureBackgroundGate("background-work");
+    if (diskPressureGate.action === "skip") {
+      if (shouldLogDiskPressureBackgroundSkip("workspace-heartbeat")) {
+        log.warn(
+          {
+            source: "workspace-heartbeat",
+            ...diskPressureBackgroundSkipLogFields(diskPressureGate),
+          },
+          "Workspace heartbeat skipped during disk pressure cleanup mode",
+        );
+      }
+      return { checked: 0, committed: 0, skipped: 0, failed: 0 };
+    }
+
     const doCheck = async (): Promise<HeartbeatCheckResult> => {
       const result: HeartbeatCheckResult = {
         checked: 0,

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

@@ -45,7 +45,7 @@ export const seedDeviceIdMigration: WorkspaceMigration = {
 
     // b. Read the lockfile to find an existing installationId.
     //    The lockfile is always under the user's home directory, never under
-    //    BASE_DATA_DIR. Check both the current and legacy filenames.
+    //    Check both the current and legacy filenames.
     const home = homedir();
     const lockCandidates = [
       join(home, ".vellum.lock.json"),

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

@@ -37,8 +37,9 @@ export const servicesConfigMigration: WorkspaceMigration = {
 
     // Skip if no legacy fields remain — either already migrated or a fresh install
     // where schema defaults are correct. We check for legacy fields instead of
-    // services existence because backfillConfigDefaults may have written a default
-    // services object before migrations run.
+    // services existence because legacy daemons (before defaults were applied
+    // only in-memory) may have written a default services object to disk
+    // before migrations run.
     const hasLegacyFields =
       "provider" in config ||
       "model" in config ||
@@ -46,7 +47,8 @@ export const servicesConfigMigration: WorkspaceMigration = {
       "webSearchProvider" in config;
     if (!hasLegacyFields) return;
 
-    // Start from existing services (may have been backfilled by loadConfig defaults)
+    // Start from existing services (legacy daemons may have written a
+    // schema-default services object to disk before this migration runs)
     // so we don't discard any non-default values already written there.
     const existingServices =
       config.services != null &&
@@ -96,8 +98,9 @@ export const servicesConfigMigration: WorkspaceMigration = {
     // 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.
+    // values, which on legacy daemons may just be schema defaults that an
+    // older loader wrote to disk. The spread preserves any extra keys that
+    // legacy daemons may have written alongside.
     services.inference = {
       ...(existingServices.inference ?? {}),
       mode: inferenceMode,

package/src/workspace/migrations/016-extract-feature-flags-to-protected.ts

@@ -7,16 +7,10 @@ import {
   unlinkSync,
   writeFileSync,
 } from "node:fs";
-import { homedir } from "node:os";
 import { join } from "node:path";
 
 import type { WorkspaceMigration } from "./types.js";
-
-/** Inlined from platform.ts to satisfy migration self-containment rule (AGENTS.md). */
-function getRootDir(): string {
-  const base = process.env.BASE_DATA_DIR?.trim() || homedir();
-  return join(base, ".vellum");
-}
+import { getVellumRoot } from "./utils.js";
 
 export const extractFeatureFlagsToProtectedMigration: WorkspaceMigration = {
   id: "016-extract-feature-flags-to-protected",
@@ -26,7 +20,7 @@ export const extractFeatureFlagsToProtectedMigration: WorkspaceMigration = {
   down(workspaceDir: string): void {
     // Reverse: read feature flags from protected directory and write them
     // back to config.json as assistantFeatureFlagValues.
-    const protectedDir = join(getRootDir(), "protected");
+    const protectedDir = join(getVellumRoot(), "protected");
     const featureFlagsPath = join(protectedDir, "feature-flags.json");
 
     if (!existsSync(featureFlagsPath)) return;
@@ -111,7 +105,7 @@ export const extractFeatureFlagsToProtectedMigration: WorkspaceMigration = {
     }
 
     // Write feature flags to protected directory
-    const protectedDir = join(getRootDir(), "protected");
+    const protectedDir = join(getVellumRoot(), "protected");
     mkdirSync(protectedDir, { recursive: true });
 
     const featureFlagsPath = join(protectedDir, "feature-flags.json");

package/src/workspace/migrations/021-move-signals-to-workspace.ts

@@ -1,7 +1,7 @@
 /**
  * Workspace migration 021: Move signals directory from root to workspace.
  *
- * Previously, `~/.vellum/signals/` lived directly under getRootDir(). This
+ * Previously, `~/.vellum/signals/` lived directly under the Vellum root. This
  * migration moves any existing signal files into `~/.vellum/workspace/signals/`
  * so that getSignalsDir() resolves correctly under the workspace.
  *
@@ -13,23 +13,17 @@
  */
 
 import { existsSync, mkdirSync, readdirSync, renameSync } from "node:fs";
-import { homedir } from "node:os";
 import { join } from "node:path";
 
 import type { WorkspaceMigration } from "./types.js";
-
-/** Inlined from platform.ts to satisfy migration self-containment rule (AGENTS.md). */
-function getRootDir(): string {
-  const base = process.env.BASE_DATA_DIR?.trim() || homedir();
-  return join(base, ".vellum");
-}
+import { getVellumRoot } from "./utils.js";
 
 export const moveSignalsToWorkspaceMigration: WorkspaceMigration = {
   id: "021-move-signals-to-workspace",
   description: "Move signals directory from root to workspace",
 
   run(workspaceDir: string): void {
-    const oldSignalsDir = join(getRootDir(), "signals");
+    const oldSignalsDir = join(getVellumRoot(), "signals");
     const newSignalsDir = join(workspaceDir, "signals");
 
     mkdirSync(newSignalsDir, { recursive: true });
@@ -56,7 +50,7 @@ export const moveSignalsToWorkspaceMigration: WorkspaceMigration = {
   },
 
   down(workspaceDir: string): void {
-    const oldSignalsDir = join(getRootDir(), "signals");
+    const oldSignalsDir = join(getVellumRoot(), "signals");
     const newSignalsDir = join(workspaceDir, "signals");
 
     mkdirSync(oldSignalsDir, { recursive: true });