@vellumai/assistant 0.7.2 → 0.8.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/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/065-bump-stale-heartbeat-interval.ts

@@ -0,0 +1,60 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+import type { WorkspaceMigration } from "./types.js";
+
+const THIRTY_MINUTES_MS = 30 * 60 * 1000;
+const LEGACY_DEFAULT_INTERVALS_MS = new Set([
+  3 * 60 * 60 * 1000,
+  6 * 60 * 60 * 1000,
+]);
+
+/**
+ * Bump stale baked heartbeat defaults to 30 minutes.
+ *
+ * Older first-launch config files materialized the then-current heartbeat
+ * default into `config.json`, so changing the schema default alone would not
+ * affect existing default users. A workspace could have intentionally selected
+ * one of these exact intervals; product intent is still to move legacy 3h/6h
+ * heartbeat schedules to the 30-minute default, and those users can reset the
+ * interval after upgrade.
+ */
+export const bumpStaleHeartbeatIntervalMigration: WorkspaceMigration = {
+  id: "065-bump-stale-heartbeat-interval",
+  description:
+    "Bump legacy heartbeat.intervalMs defaults of 3h/6h to the current 30-minute default",
+  run(workspaceDir: string): void {
+    const configPath = join(workspaceDir, "config.json");
+    if (!existsSync(configPath)) return;
+
+    let config: Record<string, unknown>;
+    try {
+      const raw = JSON.parse(readFileSync(configPath, "utf-8"));
+      if (!raw || typeof raw !== "object" || Array.isArray(raw)) return;
+      config = raw as Record<string, unknown>;
+    } catch {
+      return;
+    }
+
+    const heartbeat = config.heartbeat;
+    if (!heartbeat || typeof heartbeat !== "object" || Array.isArray(heartbeat))
+      return;
+
+    const heartbeatConfig = heartbeat as Record<string, unknown>;
+    const intervalMs = heartbeatConfig.intervalMs;
+    if (
+      typeof intervalMs !== "number" ||
+      !LEGACY_DEFAULT_INTERVALS_MS.has(intervalMs)
+    ) {
+      return;
+    }
+
+    heartbeatConfig.intervalMs = THIRTY_MINUTES_MS;
+    writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+  },
+  down(_workspaceDir: string): void {
+    // Forward-only: the stale value may have been a schema-default artifact,
+    // while 30 minutes may also have been explicitly configured later. Without
+    // per-workspace state we cannot safely distinguish those cases.
+  },
+};

package/src/workspace/migrations/066-seed-heartbeat-callsite-cost-default.ts

@@ -0,0 +1,146 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+import type { WorkspaceMigration } from "./types.js";
+
+/**
+ * Seed a cheap, bounded default for the `heartbeatAgent` LLM call site.
+ *
+ * Heartbeats are default-on and now run frequently, so they should not inherit
+ * the workspace's active chat profile. The default managed profile is Sonnet
+ * with high effort and thinking enabled, which is appropriate for interactive
+ * chat but too expensive for a periodic background triage pass.
+ *
+ * Preserve user-owned model selection. If `heartbeatAgent` already has a
+ * `profile`, `provider`, or `model`, this migration leaves the entry unchanged
+ * so call-site leaves do not silently override the selected profile/model.
+ * Speed-only legacy entries from migration 038 are treated as defaultable.
+ */
+export const seedHeartbeatCallsiteCostDefaultMigration: WorkspaceMigration = {
+  id: "066-seed-heartbeat-callsite-cost-default",
+  description:
+    "Seed cost-optimized defaults for the heartbeatAgent LLM call site",
+  run(workspaceDir: string): void {
+    if (process.env.VELLUM_DEFAULT_WORKSPACE_CONFIG_PATH) return;
+
+    const configPath = join(workspaceDir, "config.json");
+    const configExisted = existsSync(configPath);
+
+    let config: Record<string, unknown> = {};
+    if (configExisted) {
+      try {
+        const raw = JSON.parse(readFileSync(configPath, "utf-8"));
+        if (!raw || typeof raw !== "object" || Array.isArray(raw)) return;
+        config = raw as Record<string, unknown>;
+      } catch {
+        return;
+      }
+    }
+
+    const llm = readObject(config.llm) ?? {};
+    const defaultBlock = readObject(llm.default);
+    const provider = readString(defaultBlock?.provider) ?? "anthropic";
+    const cheapModel = resolveCheapModel(provider);
+    if (cheapModel === undefined) return;
+
+    const callSites = readObject(llm.callSites) ?? {};
+    const existing = readObject(callSites.heartbeatAgent) ?? {};
+    if (hasExplicitModelSelection(existing)) return;
+
+    const seeded: Record<string, unknown> = { ...existing };
+    let changed = false;
+
+    const profiles = readObject(llm.profiles) ?? {};
+    const costProfile = readObject(profiles["cost-optimized"]);
+    if (readString(costProfile?.provider) === provider) {
+      seeded.profile = "cost-optimized";
+    } else {
+      seeded.provider = provider;
+      seeded.model = cheapModel;
+    }
+    changed = true;
+
+    changed = seedMissingLeaf(seeded, "maxTokens", 2048) || changed;
+    changed = seedMissingLeaf(seeded, "effort", "low") || changed;
+    changed = seedMissingLeaf(seeded, "temperature", 0) || changed;
+
+    const thinking = readObject(seeded.thinking) ?? {};
+    const seededThinking = { ...thinking };
+    const enabledChanged = seedMissingLeaf(seededThinking, "enabled", false);
+    const streamThinkingChanged = seedMissingLeaf(
+      seededThinking,
+      "streamThinking",
+      false,
+    );
+    const thinkingChanged = enabledChanged || streamThinkingChanged;
+    if (thinkingChanged || readObject(seeded.thinking) === null) {
+      seeded.thinking = seededThinking;
+      changed = true;
+    }
+
+    const contextWindow = readObject(seeded.contextWindow) ?? {};
+    const seededContextWindow = { ...contextWindow };
+    const contextChanged = seedMissingLeaf(
+      seededContextWindow,
+      "maxInputTokens",
+      16_000,
+    );
+    if (contextChanged || readObject(seeded.contextWindow) === null) {
+      seeded.contextWindow = seededContextWindow;
+      changed = true;
+    }
+
+    if (!changed) return;
+
+    callSites.heartbeatAgent = seeded;
+    llm.callSites = callSites;
+    config.llm = llm;
+    writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+  },
+  down(_workspaceDir: string): void {
+    // Forward-only: removing the seeded default would make frequent
+    // heartbeats inherit the user's potentially expensive chat profile again.
+  },
+};
+
+// ---------------------------------------------------------------------------
+// Helpers — self-contained per workspace migrations AGENTS.md
+// ---------------------------------------------------------------------------
+
+const CHEAP_MODELS_BY_PROVIDER: Record<string, string> = {
+  anthropic: "claude-haiku-4-5-20251001",
+  openai: "gpt-5.4-nano",
+  gemini: "gemini-3-flash",
+  ollama: "llama3.2",
+  fireworks: "accounts/fireworks/models/kimi-k2p5",
+  openrouter: "anthropic/claude-haiku-4.5",
+};
+
+function resolveCheapModel(provider: string): string | undefined {
+  return CHEAP_MODELS_BY_PROVIDER[provider];
+}
+
+function hasExplicitModelSelection(value: Record<string, unknown>): boolean {
+  return "profile" in value || "provider" in value || "model" in value;
+}
+
+function seedMissingLeaf(
+  target: Record<string, unknown>,
+  key: string,
+  value: unknown,
+): boolean {
+  if (key in target) return false;
+  target[key] = value;
+  return true;
+}
+
+function readObject(value: unknown): Record<string, unknown> | null {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    return null;
+  }
+  return value as Record<string, unknown>;
+}
+
+function readString(value: unknown): string | undefined {
+  return typeof value === "string" && value.length > 0 ? value : undefined;
+}

package/src/workspace/migrations/067-release-notes-safe-storage-limits.ts

@@ -0,0 +1,14 @@
+import type { WorkspaceMigration } from "./types.js";
+
+const MIGRATION_ID = "067-release-notes-safe-storage-limits";
+
+export const releaseNotesSafeStorageLimitsMigration: WorkspaceMigration = {
+  id: MIGRATION_ID,
+  description: "Reserved migration slot for safe storage limits release notes",
+
+  run(_workspaceDir: string): void {
+    // Registered no-op slot retained for workspace migration checkpoint compatibility.
+  },
+
+  down(_workspaceDir: string): void {},
+};

package/src/workspace/migrations/068-release-notes-local-timezone.ts

@@ -0,0 +1,65 @@
+import {
+  appendFileSync,
+  existsSync,
+  readFileSync,
+  writeFileSync,
+} from "node:fs";
+import { join } from "node:path";
+
+import { getLogger } from "../../util/logger.js";
+import type { WorkspaceMigration } from "./types.js";
+
+const log = getLogger("workspace-migration-068-release-notes-local-timezone");
+
+const MIGRATION_ID = "068-release-notes-local-timezone";
+const MARKER = `<!-- release-note-id:${MIGRATION_ID} -->`;
+
+const RELEASE_NOTE = `${MARKER}
+## Local timezone grounding
+
+The assistant now grounds \`current_time\` in your local timezone across clients,
+instead of falling back to UTC when the client can report the device timezone.
+
+Manual timezone overrides still win when configured, and the assistant can help
+update a stale override after you confirm that your device timezone should be
+used going forward.
+`;
+
+export const releaseNotesLocalTimezoneMigration: WorkspaceMigration = {
+  id: MIGRATION_ID,
+  description:
+    "Append release notes for local timezone grounding to UPDATES.md",
+
+  run(workspaceDir: string): void {
+    const updatesPath = join(workspaceDir, "UPDATES.md");
+
+    try {
+      if (existsSync(updatesPath)) {
+        const existing = readFileSync(updatesPath, "utf-8");
+        if (existing.includes(MARKER)) {
+          return;
+        }
+        const needsLeadingNewline = !existing.endsWith("\n\n");
+        const prefix = existing.endsWith("\n") ? "\n" : "\n\n";
+        appendFileSync(
+          updatesPath,
+          needsLeadingNewline ? `${prefix}${RELEASE_NOTE}` : RELEASE_NOTE,
+          "utf-8",
+        );
+      } else {
+        writeFileSync(updatesPath, RELEASE_NOTE, "utf-8");
+      }
+      log.info({ path: updatesPath }, "Appended local timezone release note");
+    } catch (err) {
+      log.warn(
+        { err, path: updatesPath },
+        "Failed to append local timezone release note to UPDATES.md",
+      );
+    }
+  },
+
+  down(_workspaceDir: string): void {
+    // Forward-only: UPDATES.md is a user-facing bulletin the assistant
+    // processes and deletes on its own.
+  },
+};

package/src/workspace/migrations/069-seed-onboarding-threads.ts

@@ -0,0 +1,28 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+import type { WorkspaceMigration } from "./types.js";
+
+const ONBOARDING_THREADS = `- Figure out what kind of personality would best mesh with your user. Figure out who you are and what your voice should be. Your choice should be DISTINCT and have CHARACTER. Once you've figured this out, rewrite SOUL.md and IDENTITY.md in your own voice to define who you are.
+- Work with your user to set a custom avatar for yourself. This task is done once data/avatar/avatar-image.png exists.
+- Ask your user if they use ChatGPT, Claude or another AI tool and offer to help them import memories from there.
+- Suggest connecting to available messaging services like Slack or Telegram
+`;
+
+export const seedOnboardingThreadsMigration: WorkspaceMigration = {
+  id: "069-seed-onboarding-threads",
+  description:
+    "Seed memory/threads.md with onboarding tasks for brand new assistants",
+
+  run(workspaceDir: string): void {
+    const filePath = join(workspaceDir, "memory", "threads.md");
+    if (!existsSync(filePath)) return;
+    const current = readFileSync(filePath, "utf-8");
+    if (current.trim().length > 0) return;
+    writeFileSync(filePath, ONBOARDING_THREADS, "utf-8");
+  },
+
+  down(_workspaceDir: string): void {
+    // Forward-only: never delete user-visible memory content on rollback.
+  },
+};

package/src/workspace/migrations/070-memory-v2-summary-schema-rebuild.ts

@@ -0,0 +1,31 @@
+import type { WorkspaceMigration } from "./types.js";
+
+/**
+ * Audit-only entry for the v2 concept-page schema upgrade introduced in PR
+ * #29823 (summary_dense / summary_sparse named vectors). The destructive
+ * collection rebuild and reembed enqueue both run inside the daemon at
+ * Qdrant init time — see `maybeRebuildMemoryV2Concepts` in
+ * `assistant/src/daemon/memory-v2-startup.ts`. The "exactly-once" fence is
+ * per-collection schema introspection, not per-workspace checkpoint, so
+ * users who wipe Qdrant separately still get re-rebuilt without resetting
+ * any workspace flag.
+ *
+ * This migration exists so the registry chronology records the schema
+ * upgrade alongside the release that introduced it.
+ */
+export const memoryV2SummarySchemaRebuildMigration: WorkspaceMigration = {
+  id: "070-memory-v2-summary-schema-rebuild",
+  description:
+    "Audit entry: v2 concept-page Qdrant collection now carries summary_dense / summary_sparse named vectors. Rebuild + reembed handled by the daemon's startup hook.",
+
+  run(_workspaceDir: string): void {
+    // No-op: the actual rebuild lives in the Qdrant client layer where the
+    // collection schema is owned. Workspace migrations cannot touch Qdrant
+    // (they run before it starts and must be self-contained per
+    // assistant/src/workspace/migrations/AGENTS.md).
+  },
+
+  down(_workspaceDir: string): void {
+    // Forward-only: schema rollbacks happen outside the migration system.
+  },
+};