@vellumai/assistant 0.5.15 → 0.5.16

package/src/skills/skill-memory.ts

@@ -1,29 +1,58 @@
 import { and, eq } from "drizzle-orm";
 import { v4 as uuid } from "uuid";
 
-import { isAssistantFeatureFlagEnabled } from "../config/assistant-feature-flags.js";
 import { getConfig } from "../config/loader.js";
+import { resolveSkillStates } from "../config/skill-state.js";
+import { loadSkillCatalog, type SkillSummary } from "../config/skills.js";
 import { getDb } from "../memory/db.js";
 import { computeMemoryFingerprint } from "../memory/fingerprint.js";
 import { enqueueMemoryJob } from "../memory/jobs-store.js";
 import { memoryItems } from "../memory/schema.js";
 import { getLogger } from "../util/logger.js";
-import { type CatalogSkill, resolveCatalog } from "./catalog-install.js";
 
 const log = getLogger("skill-memory");
 
 /**
- * Build a semantically rich capability statement from a catalog skill entry.
+ * Generic input for building capability statements.
+ * Decoupled from CatalogSkill so other skill sources (e.g. bundled skills) can
+ * produce capability memories without being shoehorned into the catalog type.
+ */
+export interface SkillCapabilityInput {
+  id: string;
+  displayName: string;
+  description: string;
+  activationHints?: string[];
+  avoidWhen?: string[];
+}
+
+/**
+ * Convert a SkillSummary to a SkillCapabilityInput.
+ * SkillSummary already has flat properties, so this is a straightforward mapping.
+ */
+export function fromSkillSummary(entry: SkillSummary): SkillCapabilityInput {
+  return {
+    id: entry.id,
+    displayName: entry.displayName,
+    description: entry.description,
+    activationHints: entry.activationHints,
+    avoidWhen: entry.avoidWhen,
+  };
+}
+
+/**
+ * Build a semantically rich capability statement from a skill capability input.
  * Truncated to 500 chars max (matching the limit used by memory item extraction).
  */
-export function buildCapabilityStatement(entry: CatalogSkill): string {
-  const displayName = entry.metadata?.vellum?.["display-name"] ?? entry.name;
-  const activationHints = entry.metadata?.vellum?.["activation-hints"];
+export function buildCapabilityStatement(input: SkillCapabilityInput): string {
+  const { displayName, activationHints, avoidWhen } = input;
 
-  let statement = `The "${displayName}" skill (${entry.id}) is available. ${entry.description}.`;
+  let statement = `The "${displayName}" skill (${input.id}) is available. ${input.description}.`;
   if (activationHints && activationHints.length > 0) {
     statement += ` Use when: ${activationHints.join("; ")}.`;
   }
+  if (avoidWhen && avoidWhen.length > 0) {
+    statement += ` Avoid when: ${avoidWhen.join("; ")}.`;
+  }
 
   // Truncate to 500 chars max
   if (statement.length > 500) {
@@ -34,17 +63,17 @@ export function buildCapabilityStatement(entry: CatalogSkill): string {
 }
 
 /**
- * Upsert a capability memory item for a catalog skill.
+ * Upsert a capability memory item for a skill.
  * Best-effort: errors are logged but never thrown.
  */
 export function upsertSkillCapabilityMemory(
   skillId: string,
-  entry: CatalogSkill,
+  input: SkillCapabilityInput,
 ): void {
   try {
     const db = getDb();
     const subject = `skill:${skillId}`;
-    const statement = buildCapabilityStatement(entry);
+    const statement = buildCapabilityStatement(input);
     const kind = "capability";
     const scopeId = "default";
     const confidence = 1.0;
@@ -169,30 +198,39 @@ export function deleteSkillCapabilityMemory(skillId: string): void {
 }
 
 /**
- * Seed capability memory items for all catalog skills.
- * Prunes stale entries whose skills are no longer in the catalog.
+ * Seed capability memory items for all enabled skills (bundled, managed, workspace, extra).
+ * Prunes stale entries whose skills are no longer in the enabled set.
  * Best-effort: errors are logged but never thrown.
  */
-export async function seedCatalogSkillMemories(): Promise<void> {
+export function seedCatalogSkillMemories(): void {
   try {
-    const catalog = await resolveCatalog();
+    const catalog = loadSkillCatalog();
     const config = getConfig();
+    const resolved = resolveSkillStates(catalog, config);
+    const enabled = resolved.filter((r) => r.state === "enabled");
+
     const catalogIds = new Set<string>();
+    for (const { summary } of enabled) {
+      catalogIds.add(summary.id);
+      const input = fromSkillSummary(summary);
 
-    for (const entry of catalog) {
-      // Skip skills whose feature flag is disabled
-      const flagId = entry.metadata?.vellum?.["feature-flag"];
-      if (flagId) {
-        if (!isAssistantFeatureFlagEnabled(flagId, config)) {
-          continue;
+      // Enrich mcp-setup description with configured server names
+      if (summary.id === "mcp-setup") {
+        const servers = config.mcp?.servers;
+        if (servers) {
+          const names = Object.keys(servers).filter(
+            (name) => servers[name]?.enabled !== false,
+          );
+          if (names.length > 0) {
+            input.description += ` Configured: ${names.join(", ")}`;
+          }
         }
       }
 
-      catalogIds.add(entry.id);
-      upsertSkillCapabilityMemory(entry.id, entry);
+      upsertSkillCapabilityMemory(summary.id, input);
     }
 
-    // Prune stale capability memories for skills no longer in catalog
+    // Prune stale capability memories for skills no longer in the enabled set
     const db = getDb();
     const allCapabilities = db
       .select()
@@ -208,6 +246,7 @@ export async function seedCatalogSkillMemories(): Promise<void> {
 
     const now = Date.now();
     for (const item of allCapabilities) {
+      if (!item.subject.startsWith("skill:")) continue;
       const itemSkillId = item.subject.replace("skill:", "");
       if (!catalogIds.has(itemSkillId)) {
         db.update(memoryItems)

package/src/tools/memory/handlers.test.ts

@@ -4,34 +4,10 @@
  * Covers happy path (multi-source results), empty results, degraded mode
  * (embeddings/Qdrant unavailable), scope filtering, and error handling.
  */
-import { mkdtempSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import {
-  afterAll,
-  beforeAll,
-  beforeEach,
-  describe,
-  expect,
-  mock,
-  test,
-} from "bun:test";
-
-const testDir = mkdtempSync(join(tmpdir(), "memory-recall-handler-"));
+import { beforeAll, beforeEach, describe, expect, mock, test } from "bun:test";
 
 // ── Module mocks (must precede production imports) ───────────────────
 
-mock.module("../../util/platform.js", () => ({
-  getDataDir: () => testDir,
-  isMacOS: () => process.platform === "darwin",
-  isLinux: () => process.platform === "linux",
-  isWindows: () => process.platform === "win32",
-  getPidPath: () => join(testDir, "test.pid"),
-  getDbPath: () => join(testDir, "test.db"),
-  getLogPath: () => join(testDir, "test.log"),
-  ensureDataDir: () => {},
-}));
-
 mock.module("../../util/logger.js", () => ({
   getLogger: () =>
     new Proxy({} as Record<string, unknown>, {
@@ -259,10 +235,6 @@ describe("handleMemoryRecall", () => {
     clearEmbeddingBackendCache();
   });
 
-  afterAll(() => {
-    rmSync(testDir, { recursive: true, force: true });
-  });
-
   // ── Input validation ──────────────────────────────────────────────
 
   test("returns error when query is missing", async () => {

package/src/tools/permission-checker.ts

@@ -137,24 +137,6 @@ export class PermissionChecker {
       }
 
       if (result.decision === "prompt") {
-        // dangerouslySkipPermissions: when enabled, auto-approve all prompts
-        // without user interaction. Deny rules are still respected (they
-        // return before reaching this block).
-        //
-        // Note: unlike guardian auto-approve and temporary overrides below,
-        // this intentionally does NOT check `context.requireFreshApproval`.
-        // The setting is designed to skip ALL interactive prompts
-        // unconditionally — it is an explicit operator opt-out from the
-        // permission system, so requireFreshApproval does not apply.
-        const cfg = getConfig();
-        if (cfg.permissions.dangerouslySkipPermissions) {
-          log.info(
-            { toolName: name, riskLevel },
-            "dangerouslySkipPermissions active — auto-approving without prompt",
-          );
-          return { allowed: true, decision: "dangerously_skip_permissions", riskLevel };
-        }
-
         // Guardian-trust sessions (e.g. scheduled jobs, reminders) should be
         // able to use bundled tools without interactive approval. The guardian
         // is the owner - prompting makes no sense when there is no client.

package/src/tools/skills/skill-script-runner.ts

@@ -40,7 +40,7 @@ export async function runSkillToolScript(
   context: ToolContext,
   options?: RunSkillToolScriptOptions,
 ): Promise<ToolExecutionResult> {
-  if (options?.target === "sandbox") {
+  if (options?.target === "sandbox" && !options?.bundled) {
     return runSkillToolScriptSandbox(skillDir, executorPath, input, context, {
       timeoutMs: options.timeoutMs,
       expectedSkillVersionHash: options.expectedSkillVersionHash,

package/src/util/device-id.ts

@@ -8,8 +8,7 @@
  * Path resolution:
  *   - Containerized (IS_CONTAINERIZED=true): uses /home/assistant (the assistant
  *     user's persistent home dir) so device.json lives on the assistant's own
- *     filesystem rather than the shared data volume. Falls back to the legacy
- *     BASE_DATA_DIR location for migration.
+ *     filesystem rather than the shared data volume.
  *   - Local (single or multi-instance): uses homedir() so all instances on the
  *     same machine share a single device ID.
  *
@@ -45,22 +44,6 @@ export function getDeviceIdBaseDir(): string {
   return homedir();
 }
 
-/**
- * Resolve the legacy base directory for device.json migration.
- *
- * Returns the old containerized path (via BASE_DATA_DIR env var) so we can
- * fall back to reading device.json from the shared volume if it hasn't been
- * migrated yet. Returns undefined when not containerized or when no legacy
- * path exists.
- */
-function getLegacyDeviceIdBaseDir(): string | undefined {
-  if (!getIsContainerized()) {
-    return undefined;
-  }
-  const baseDataDir = process.env.BASE_DATA_DIR?.trim() || undefined;
-  return baseDataDir;
-}
-
 /**
  * Get the stable device ID for this machine.
  *
@@ -96,55 +79,10 @@ export function getDeviceId(): string {
       }
     }
   } catch (err) {
-    log.warn({ err }, "Failed to read device.json — checking legacy path");
-  }
-
-  // Migration fallback: check the legacy location (shared volume) if the new
-  // location doesn't have a valid device.json yet.
-  const legacyBase = getLegacyDeviceIdBaseDir();
-  if (legacyBase) {
-    const legacyPath = join(legacyBase, ".vellum", "device.json");
-    try {
-      if (existsSync(legacyPath)) {
-        const raw = JSON.parse(readFileSync(legacyPath, "utf-8"));
-        if (
-          raw &&
-          typeof raw === "object" &&
-          typeof raw.deviceId === "string" &&
-          raw.deviceId.length > 0
-        ) {
-          cached = raw.deviceId as string;
-          log.info(
-            { deviceId: cached },
-            "Resolved device ID from legacy device.json — will persist to new location",
-          );
-          // Persist to the new location so future reads don't need the fallback
-          try {
-            mkdirSync(vellumDir, { recursive: true });
-            writeFileSync(
-              filePath,
-              JSON.stringify({ deviceId: cached }, null, 2) + "\n",
-              { mode: 0o644 },
-            );
-            log.info("Migrated device.json to new location");
-          } catch (writeErr) {
-            log.warn(
-              { err: writeErr },
-              "Failed to migrate device.json to new location",
-            );
-          }
-          return cached;
-        }
-      }
-    } catch (err) {
-      log.warn(
-        { err },
-        "Failed to read legacy device.json — generating new device ID",
-      );
-    }
+    log.warn({ err }, "Failed to read device.json — generating new device ID");
   }
 
-  // Either the file doesn't exist at either location, or deviceId was missing/empty.
+  // Either the file doesn't exist or deviceId was missing/empty.
   // Generate a new UUID and persist it.
   try {
     mkdirSync(vellumDir, { recursive: true });

package/src/workspace/git-service.ts

@@ -1,4 +1,4 @@
-import { execFile } from "node:child_process";
+import { execFile, spawnSync } from "node:child_process";
 import {
   existsSync,
   readFileSync,
@@ -258,20 +258,41 @@ export class WorkspaceGitService {
   }
 
   /**
-   * Remove `.git/index.lock` if it exists.
+   * Remove `.git/index.lock` if it exists and no external process holds it.
    *
    * This method is always called inside the mutex, so no git operation from
-   * our code can be concurrently holding the lock. Any lock file present is
-   * stale — left behind by a crashed process or an external command that
-   * has already exited.
+   * our code can be concurrently holding the lock. However, an external git
+   * process (user running `git add`, IDE tooling, etc.) could legitimately
+   * hold the lock. We use `lsof` to check — if any process has the file
+   * open, we leave it alone. If no process holds it, it's stale (crashed
+   * process) and safe to remove.
    */
   private cleanStaleLockFile(): void {
     const lockPath = join(this.workspaceDir, ".git", "index.lock");
+    if (!existsSync(lockPath)) {
+      return;
+    }
+
+    try {
+      const result = spawnSync("lsof", ["-t", lockPath], {
+        timeout: 3000,
+        stdio: ["ignore", "pipe", "ignore"],
+      });
+      if (result.status === 0 && result.stdout?.length > 0) {
+        log.debug("index.lock held by an active process, skipping removal");
+        return;
+      }
+    } catch {
+      // lsof unavailable or errored — fall through to remove.
+      // On platforms without lsof this degrades to unconditional removal,
+      // which is the same as the previous behavior.
+    }
+
     try {
       unlinkSync(lockPath);
       log.debug("Removed stale index.lock");
     } catch {
-      // File doesn't exist or can't be removed — move on.
+      // File was removed between check and unlink, or can't be removed — move on.
     }
   }