@vellumai/assistant 0.5.15 → 0.6.0

package/src/skills/skill-memory.ts

@@ -1,29 +1,80 @@
-import { and, eq } from "drizzle-orm";
+import { and, eq, sql } 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 { memoryGraphNodes } from "../memory/schema.js";
 import { getLogger } from "../util/logger.js";
-import { type CatalogSkill, resolveCatalog } from "./catalog-install.js";
+import { getCachedCatalogSync } from "./catalog-cache.js";
+import type { CatalogSkill } from "./catalog-install.js";
 
 const log = getLogger("skill-memory");
 
+/** Escape SQL LIKE wildcards so they match literally.
+ * Uses backslash as the escape character — callers must pair with ESCAPE '\\'. */
+function escapeLike(s: string): string {
+  return s.replace(/\\/g, "\\\\").replace(/%/g, "\\%").replace(/_/g, "\\_");
+}
+
+/**
+ * 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 catalog skill entry.
+ * Convert a CatalogSkill to a SkillCapabilityInput.
+ * CatalogSkill stores display-name and hints inside nested metadata.
+ */
+export function fromCatalogSkill(entry: CatalogSkill): SkillCapabilityInput {
+  return {
+    id: entry.id,
+    displayName: entry.metadata?.vellum?.["display-name"] ?? entry.name,
+    description: entry.description,
+    activationHints: entry.metadata?.vellum?.["activation-hints"],
+    avoidWhen: entry.metadata?.vellum?.["avoid-when"],
+  };
+}
+
+/**
+ * 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) {
@@ -33,134 +84,140 @@ export function buildCapabilityStatement(entry: CatalogSkill): string {
   return statement;
 }
 
+/** Default emotional charge for capability graph nodes. */
+const DEFAULT_EMOTIONAL_CHARGE = JSON.stringify({
+  valence: 0,
+  intensity: 0.1,
+  decayCurve: "linear",
+  decayRate: 0.05,
+  originalIntensity: 0.1,
+});
+
 /**
- * Upsert a capability memory item for a catalog skill.
+ * Upsert a capability memory graph node 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 kind = "capability";
+    const statement = buildCapabilityStatement(input);
+    const content = `skill:${skillId}\n${statement}`;
     const scopeId = "default";
-    const confidence = 1.0;
-    const importance = 0.7;
-    const fingerprint = computeMemoryFingerprint(
-      scopeId,
-      kind,
-      subject,
-      statement,
-    );
     const now = Date.now();
 
     const existing = db
       .select()
-      .from(memoryItems)
+      .from(memoryGraphNodes)
       .where(
         and(
-          eq(memoryItems.kind, kind),
-          eq(memoryItems.subject, subject),
-          eq(memoryItems.scopeId, scopeId),
+          eq(memoryGraphNodes.type, "procedural"),
+          sql`${memoryGraphNodes.content} LIKE ${'skill:' + escapeLike(skillId) + '\n%'} ESCAPE '\\'`,
+          eq(memoryGraphNodes.scopeId, scopeId),
         ),
       )
       .get();
 
     if (existing) {
       if (
-        existing.status === "active" &&
-        existing.fingerprint === fingerprint
+        existing.content === content &&
+        existing.fidelity !== "gone"
       ) {
-        // Same content — just touch lastSeenAt
-        db.update(memoryItems)
-          .set({ lastSeenAt: now })
-          .where(eq(memoryItems.id, existing.id))
+        // Same content — just touch lastAccessed
+        db.update(memoryGraphNodes)
+          .set({ lastAccessed: now })
+          .where(eq(memoryGraphNodes.id, existing.id))
           .run();
         return;
       }
 
-      if (existing.status === "active") {
-        // Content changed — update statement and fingerprint
-        db.update(memoryItems)
+      if (existing.fidelity !== "gone") {
+        // Content changed — update content
+        db.update(memoryGraphNodes)
           .set({
-            statement,
-            fingerprint,
-            lastSeenAt: now,
+            content,
+            lastAccessed: now,
           })
-          .where(eq(memoryItems.id, existing.id))
+          .where(eq(memoryGraphNodes.id, existing.id))
           .run();
-        enqueueMemoryJob("embed_item", { itemId: existing.id });
+        enqueueMemoryJob("embed_graph_node", { nodeId: existing.id });
         return;
       }
 
-      // status === "deleted" or other — reactivate
-      db.update(memoryItems)
+      // fidelity === "gone" — reactivate
+      db.update(memoryGraphNodes)
         .set({
-          status: "active",
-          statement,
-          fingerprint,
-          lastSeenAt: now,
-          firstSeenAt: now,
+          fidelity: "vivid",
+          content,
+          created: now,
+          lastAccessed: now,
         })
-        .where(eq(memoryItems.id, existing.id))
+        .where(eq(memoryGraphNodes.id, existing.id))
         .run();
-      enqueueMemoryJob("embed_item", { itemId: existing.id });
+      enqueueMemoryJob("embed_graph_node", { nodeId: existing.id });
+      log.info({ skillId, nodeId: existing.id }, "Reactivated skill capability memory");
       return;
     }
 
-    // No existing — insert new row
+    // No existing — insert new graph node
     const id = uuid();
-    db.insert(memoryItems)
+    db.insert(memoryGraphNodes)
       .values({
         id,
-        kind,
-        subject,
-        statement,
-        status: "active",
-        confidence,
-        importance,
-        fingerprint,
-        sourceType: "extraction",
+        content,
+        type: "procedural",
+        created: now,
+        lastAccessed: now,
+        lastConsolidated: now,
+        emotionalCharge: DEFAULT_EMOTIONAL_CHARGE,
+        fidelity: "vivid",
+        confidence: 1.0,
+        significance: 0.7,
+        stability: 14,
+        reinforcementCount: 0,
+        lastReinforced: now,
+        sourceConversations: JSON.stringify([]),
+        sourceType: "inferred",
+        narrativeRole: null,
+        partOfStory: null,
         scopeId,
-        firstSeenAt: now,
-        lastSeenAt: now,
       })
       .run();
-    enqueueMemoryJob("embed_item", { itemId: id });
+    enqueueMemoryJob("embed_graph_node", { nodeId: id });
+    log.info({ skillId, nodeId: id }, "Created skill capability memory");
   } catch (err) {
     log.warn({ err, skillId }, "Failed to upsert skill capability memory");
   }
 }
 
 /**
- * Soft-delete the capability memory item for a skill.
+ * Soft-delete the capability memory graph node for a skill.
  * Best-effort: errors are logged but never thrown.
  */
 export function deleteSkillCapabilityMemory(skillId: string): void {
   try {
     const db = getDb();
-    const subject = `skill:${skillId}`;
     const now = Date.now();
 
     const existing = db
       .select()
-      .from(memoryItems)
+      .from(memoryGraphNodes)
       .where(
         and(
-          eq(memoryItems.kind, "capability"),
-          eq(memoryItems.subject, subject),
-          eq(memoryItems.scopeId, "default"),
+          eq(memoryGraphNodes.type, "procedural"),
+          sql`${memoryGraphNodes.content} LIKE ${'skill:' + escapeLike(skillId) + '\n%'} ESCAPE '\\'`,
+          eq(memoryGraphNodes.scopeId, "default"),
+          sql`${memoryGraphNodes.fidelity} != 'gone'`,
         ),
       )
       .get();
 
-    if (existing && existing.status !== "deleted") {
-      db.update(memoryItems)
-        .set({ status: "deleted", lastSeenAt: now })
-        .where(eq(memoryItems.id, existing.id))
+    if (existing) {
+      db.update(memoryGraphNodes)
+        .set({ fidelity: "gone", lastAccessed: now })
+        .where(eq(memoryGraphNodes.id, existing.id))
         .run();
     }
   } catch (err) {
@@ -169,54 +226,111 @@ 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 graph nodes 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
+    // and not available in the remote/local catalog.
     const db = getDb();
     const allCapabilities = db
       .select()
-      .from(memoryItems)
+      .from(memoryGraphNodes)
       .where(
         and(
-          eq(memoryItems.kind, "capability"),
-          eq(memoryItems.scopeId, "default"),
-          eq(memoryItems.status, "active"),
+          eq(memoryGraphNodes.type, "procedural"),
+          eq(memoryGraphNodes.scopeId, "default"),
+          sql`${memoryGraphNodes.fidelity} != 'gone'`,
         ),
       )
       .all();
 
+    const allLocalSkillIds = new Set(catalog.map((s) => s.id));
+    const cachedCatalog = getCachedCatalogSync();
+    const cachedCatalogIds = new Set(cachedCatalog.map((s) => s.id));
+
     const now = Date.now();
     for (const item of allCapabilities) {
-      const itemSkillId = item.subject.replace("skill:", "");
-      if (!catalogIds.has(itemSkillId)) {
-        db.update(memoryItems)
-          .set({ status: "deleted", lastSeenAt: now })
-          .where(eq(memoryItems.id, item.id))
-          .run();
-      }
+      if (!item.content.startsWith("skill:")) continue;
+      const itemSkillId = item.content.split("\n")[0].replace("skill:", "");
+
+      // Keep enabled skills
+      if (catalogIds.has(itemSkillId)) continue;
+
+      // Keep uninstalled catalog skills that are still in the remote catalog
+      if (cachedCatalogIds.has(itemSkillId)) continue;
+
+      // If the catalog cache is empty (cold start, before async fetch),
+      // we can't tell whether an unknown skill is a stale entry or
+      // a valid uninstalled catalog skill. Only prune skills we can
+      // positively identify as local-but-disabled.
+      if (cachedCatalogIds.size === 0 && !allLocalSkillIds.has(itemSkillId)) continue;
+
+      log.info({ skillId: itemSkillId, nodeId: item.id, catalogSize: catalogIds.size, cacheSize: cachedCatalogIds.size }, "Pruning stale skill capability memory");
+      db.update(memoryGraphNodes)
+        .set({ fidelity: "gone", lastAccessed: now })
+        .where(eq(memoryGraphNodes.id, item.id))
+        .run();
     }
   } catch (err) {
     log.warn({ err }, "Failed to seed catalog skill memories");
   }
 }
+
+/**
+ * Seed capability memories for catalog skills that are not yet installed.
+ * This makes uninstalled skills discoverable via memory injection so the LLM
+ * can auto-install them via skill_load when relevant.
+ * Best-effort: errors are logged but never thrown.
+ */
+export async function seedUninstalledCatalogSkillMemories(): Promise<void> {
+  try {
+    const { getCatalog } = await import("./catalog-cache.js");
+    const fullCatalog = await getCatalog();
+    if (fullCatalog.length === 0) return;
+
+    const installedCatalog = loadSkillCatalog();
+    const installedIds = new Set(installedCatalog.map((s) => s.id));
+
+    const config = getConfig();
+    for (const entry of fullCatalog) {
+      if (installedIds.has(entry.id)) continue;
+
+      const flagKey = entry.metadata?.vellum?.["feature-flag"];
+      if (flagKey && !isAssistantFeatureFlagEnabled(flagKey, config)) continue;
+
+      const input = fromCatalogSkill(entry);
+      upsertSkillCapabilityMemory(entry.id, input);
+    }
+  } catch (err) {
+    log.warn({ err }, "Failed to seed uninstalled catalog skill memories");
+  }
+}

package/src/skills/skillssh-registry.ts

@@ -5,6 +5,7 @@ import { dirname, join, resolve, sep } from "node:path";
 
 import { getWorkspaceSkillsDir } from "../util/platform.js";
 import { upsertSkillsIndex } from "./catalog-install.js";
+import { computeSkillHash, writeInstallMeta } from "./install-meta.js";
 
 // ─── Types ───────────────────────────────────────────────────────────────────
 
@@ -434,9 +435,12 @@ export function validateSkillSlug(slug: string): void {
  * 1. Validates the skill slug for path safety
  * 2. Fetches all files from `skills/<skillSlug>/` in the source repo
  * 3. Writes them to `<workspace>/skills/<skillSlug>/` with path traversal protection
- * 4. Writes `version.json` with origin metadata
- * 5. Runs `bun install` if a `package.json` is present
- * 6. Registers the skill in SKILLS.md only after all steps succeed
+ * 4. Writes `install-meta.json` with origin metadata
+ * 5. Installs npm dependencies (if package.json exists)
+ * 6. Updates SKILLS.md index
+ *
+ * Auto-enable and memory seeding are handled by the caller (e.g.
+ * `postInstallSkill()` in the daemon, or left to the user for CLI installs).
  */
 export async function installExternalSkill(
   owner: string,
@@ -444,6 +448,7 @@ export async function installExternalSkill(
   skillSlug: string,
   overwrite: boolean,
   ref?: string,
+  contactId?: string,
 ): Promise<void> {
   // Validate slug before using in filesystem paths
   validateSkillSlug(skillSlug);
@@ -480,20 +485,19 @@ export async function installExternalSkill(
     writeFileSync(destPath, content, "utf-8");
   }
 
-  // Write origin metadata
-  const meta = {
-    origin: "skills.sh",
-    source: `${owner}/${repo}`,
-    skillSlug,
+  // Write install metadata
+  writeInstallMeta(skillDir, {
+    origin: "skillssh",
+    slug: skillSlug,
+    sourceRepo: `${owner}/${repo}`,
     installedAt: new Date().toISOString(),
-  };
-  writeFileSync(
-    join(skillDir, "version.json"),
-    JSON.stringify(meta, null, 2) + "\n",
-    "utf-8",
-  );
+    ...(contactId ? { installedBy: contactId } : {}),
+    contentHash: computeSkillHash(skillDir) ?? undefined,
+  });
 
-  // Install npm dependencies if the skill ships a package.json
+  // Post-install: install dependencies first, then index the skill.
+  // Running bun install before upsertSkillsIndex ensures we don't index a
+  // skill whose dependencies failed to install.
   if (existsSync(join(skillDir, "package.json"))) {
     const bunPath = `${homedir()}/.bun/bin`;
     execSync("bun install", {
@@ -502,7 +506,5 @@ export async function installExternalSkill(
       env: { ...process.env, PATH: `${bunPath}:${process.env.PATH}` },
     });
   }
-
-  // Register in SKILLS.md only after files are written and deps installed
   upsertSkillsIndex(skillSlug);
 }

package/src/tasks/task-runner.ts

@@ -64,8 +64,10 @@ export async function runTask(
     // Scheduled section; non-schedule tasks use "background" to stay out of
     // the main conversation list.
     conversationType: opts.source === "schedule" ? undefined : "background",
-    source: opts.source,
+    source: opts.source === "schedule" ? "schedule" : "task",
     scheduleJobId: opts.scheduleJobId,
+    groupId:
+      opts.source === "schedule" ? "system:scheduled" : "system:background",
     origin: "task",
     systemHint: `Task: ${task.title}`,
   });

package/src/telemetry/usage-telemetry-reporter.test.ts

@@ -504,17 +504,15 @@ describe("UsageTelemetryReporter", () => {
     // No HTTP call should have been made
     expect(mockFetch).not.toHaveBeenCalled();
 
-    // All 6 watermarks should have been advanced (3 timestamps + 3 IDs)
-    expect(mockSetMemoryCheckpoint).toHaveBeenCalledTimes(6);
+    // All 3 timestamp watermarks should have been advanced (IDs left untouched
+    // so the compound-cursor branch stays active)
+    expect(mockSetMemoryCheckpoint).toHaveBeenCalledTimes(3);
 
     const calls = mockSetMemoryCheckpoint.mock.calls;
     const keys = calls.map((c) => c[0]);
     expect(keys).toContain("telemetry:usage:last_reported_at");
-    expect(keys).toContain("telemetry:usage:last_reported_id");
     expect(keys).toContain("telemetry:turns:last_reported_at");
-    expect(keys).toContain("telemetry:turns:last_reported_id");
     expect(keys).toContain("telemetry:lifecycle:last_reported_at");
-    expect(keys).toContain("telemetry:lifecycle:last_reported_id");
   });
 
   test("events sent normally after re-enabling collectUsageData", async () => {

package/src/tools/browser/runtime-check.ts

@@ -1,6 +1,7 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 
+import { ensureBun } from "../../util/bun-runtime.js";
 import { getExternalDir } from "../../util/platform.js";
 
 export interface BrowserRuntimeStatus {
@@ -83,7 +84,8 @@ export async function importPlaywright(): Promise<typeof import("playwright")> {
     if (!existsSync(join(externalDir, "package.json"))) {
       writeFileSync(join(externalDir, "package.json"), '{"private":true}\n');
     }
-    const proc = Bun.spawn(["bun", "add", "playwright"], {
+    const bunPath = await ensureBun();
+    const proc = Bun.spawn([bunPath, "add", "playwright"], {
       cwd: externalDir,
       stdout: "pipe",
       stderr: "pipe",