@vellumai/assistant 0.10.2 → 0.10.3-dev.202606252046.9075fd5

package/src/workspace/migrations/031-drop-user-md.ts

@@ -8,16 +8,8 @@ import {
   writeFileSync,
 } from "node:fs";
 import { basename, join } from "node:path";
+import { Database } from "bun:sqlite";
 
-import { eq } from "drizzle-orm";
-
-import {
-  findGuardianForChannel,
-  generateUserFileSlug,
-  listGuardianChannels,
-} from "../../contacts/contact-store.js";
-import { getDb } from "../../memory/db-connection.js";
-import { contacts } from "../../memory/schema/contacts.js";
 import { getLogger } from "../../util/logger.js";
 import type { WorkspaceMigration } from "./types.js";
 
@@ -25,11 +17,11 @@ const log = getLogger("workspace-migration-031-drop-user-md");
 
 // ── Inlined helpers ───────────────────────────────────────────────
 //
-// Per AGENTS.md, migrations should minimize cross-module imports so
-// they remain stable as code around them evolves. The helpers below
-// are duplicated inline (rather than imported from
-// `util/strip-comment-lines.js` and `prompts/system-prompt.js`) so
-// this migration does not regress if those modules change later.
+// AGENTS.md requires each migration to be self-contained: it may import
+// only `./types.js`, `./utils.js`, the logger, and runtime built-ins.
+// The helpers below (including the guardian DB read and the userFile
+// slug) are inlined so this migration does not regress if the modules
+// they originate from change later.
 
 /**
  * Strip lines starting with `_` (comment convention for prompt .md files)
@@ -123,13 +115,59 @@ function isValidSlug(slug: string): boolean {
   return basename(slug) === slug && slug !== "." && slug !== "..";
 }
 
+/**
+ * Strip LIKE metacharacters so the prefix match runs literally. SQLite has
+ * no default LIKE escape character, so strip rather than escape. Inlined
+ * from `contacts/contact-store.ts`.
+ */
+function escapeLike(value: string): string {
+  return value.replace(/%/g, "").replace(/_/g, "");
+}
+
+/** Pure slug transform applied to a display name. */
+function computeUserFileBaseSlug(displayName: string): string {
+  return (
+    displayName
+      .toLowerCase()
+      .replace(/[^a-z0-9]+/g, "-")
+      .replace(/^-+|-+$/g, "")
+      .slice(0, 100) || "user"
+  );
+}
+
+/**
+ * Generate a collision-free `users/<slug>.md` filename for a display name,
+ * inlined verbatim from `contacts/contact-store.ts` to keep this migration
+ * self-contained. Produces "alice.md", "alice-2.md", etc.
+ */
+function generateUserFileSlug(db: Database, displayName: string): string {
+  const slug = computeUserFileBaseSlug(displayName);
+
+  const rows = db
+    .query<{ user_file: string | null }, [string]>(
+      `SELECT user_file FROM contacts WHERE user_file LIKE ?`,
+    )
+    .all(`${escapeLike(slug)}%`);
+
+  const taken = new Set(rows.map((r) => r.user_file?.toLowerCase()));
+
+  const base = `${slug}.md`;
+  if (!taken.has(base)) return base;
+
+  for (let i = 2; ; i++) {
+    const candidate = `${slug}-${i}.md`;
+    if (!taken.has(candidate)) return candidate;
+  }
+}
+
 /**
  * Delete the legacy `USER.md` at the workspace root after migrating
  * any customized content into `users/<slug>.md`.
  *
- * Handles four relevant states:
- *   1. Fresh install, no guardian → no-op (nothing to migrate yet;
- *      `USER.md` is no longer seeded post PR 11).
+ * Handles these relevant states:
+ *   1. No local guardian → preserve a customized `USER.md` (the local
+ *      mirror can be stale, so a customized profile may still belong to a
+ *      real guardian); delete only the unmodified template/empty file.
  *   2. Pre-017 customized `USER.md`, guardian has no `userFile` →
  *      backfill the slug, copy `USER.md` → `users/<slug>.md`, delete `USER.md`.
  *   3. Post-017 state where `users/<slug>.md` already has content →
@@ -137,6 +175,12 @@ function isValidSlug(slug: string): boolean {
  *   4. Missing `users/<slug>.md` after guardian is resolved → seed a bare
  *      `GUARDIAN_PERSONA_TEMPLATE` scaffold so downstream readers have a file.
  */
+interface GuardianRow {
+  id: string;
+  display_name: string;
+  user_file: string | null;
+}
+
 export const dropUserMdMigration: WorkspaceMigration = {
   id: "031-drop-user-md",
   description:
@@ -145,163 +189,203 @@ export const dropUserMdMigration: WorkspaceMigration = {
   run(workspaceDir: string): void {
     const userMdPath = join(workspaceDir, "USER.md");
 
-    // Resolve the guardian contact. Prefer the vellum-channel binding
-    // (the canonical local/native guardian); fall back to whichever
-    // guardian has the most recently verified active channel.
-    let guardian: { id: string; displayName: string; userFile: string | null };
+    const dbPath = join(workspaceDir, "data", "db", "assistant.db");
+    if (!existsSync(dbPath)) return; // DB not created yet — defer cleanup.
+
+    let db: Database;
     try {
-      const vellumGuardian = findGuardianForChannel("vellum");
-      if (vellumGuardian) {
-        guardian = {
-          id: vellumGuardian.contact.id,
-          displayName: vellumGuardian.contact.displayName,
-          userFile: vellumGuardian.contact.userFile ?? null,
-        };
-      } else {
-        const anyGuardian = listGuardianChannels();
-        if (!anyGuardian) {
-          // Fresh install or pre-onboarding. If a stale USER.md somehow
-          // remains on disk (e.g. leftover from an older build), best-
-          // effort remove it so future first runs are clean.
-          if (existsSync(userMdPath)) {
-            try {
-              unlinkSync(userMdPath);
-              log.info(
-                { path: userMdPath },
-                "Deleted stale pre-onboarding USER.md with no guardian",
-              );
-            } catch (err) {
-              log.warn(
-                { err, path: userMdPath },
-                "Failed to delete pre-onboarding USER.md; leaving in place",
-              );
-            }
-          }
-          return;
-        }
-        guardian = {
-          id: anyGuardian.contact.id,
-          displayName: anyGuardian.contact.displayName,
-          userFile: anyGuardian.contact.userFile ?? null,
-        };
-      }
+      db = new Database(dbPath);
     } catch (err) {
-      // DB not ready or query failed — leave USER.md alone. The next
-      // startup after DB init will try again.
-      log.warn(
-        { err },
-        "Failed to resolve guardian contact; deferring USER.md cleanup",
-      );
+      log.warn({ err }, "Cannot open assistant DB; deferring USER.md cleanup");
       return;
     }
 
-    // Backfill a userFile slug on the guardian contact if one isn't set.
-    if (!guardian.userFile) {
+    try {
+      // Resolve the guardian contact from the local DB. Prefer the
+      // vellum-channel binding (the canonical native guardian); fall back to
+      // whichever guardian has the most recently verified active channel.
+      let guardianRow: GuardianRow | null;
       try {
-        const slug = generateUserFileSlug(guardian.displayName);
-        const db = getDb();
-        db.update(contacts)
-          .set({ userFile: slug })
-          .where(eq(contacts.id, guardian.id))
-          .run();
-        guardian.userFile = slug;
-        log.info(
-          { contactId: guardian.id, slug },
-          "Backfilled missing guardian.userFile",
-        );
+        guardianRow =
+          db
+            .query<GuardianRow, []>(
+              `SELECT c.id AS id, c.display_name AS display_name, c.user_file AS user_file
+                 FROM contacts c JOIN contact_channels cc ON cc.contact_id = c.id
+                WHERE c.role = 'guardian' AND cc.status = 'active'
+                ORDER BY (cc.type = 'vellum') DESC, cc.verified_at DESC
+                LIMIT 1`,
+            )
+            .get() ?? null;
       } catch (err) {
+        // DB not ready or query failed — leave USER.md alone. The next
+        // startup after DB init tries again.
         log.warn(
-          { err, contactId: guardian.id },
-          "Failed to backfill guardian.userFile; deferring USER.md cleanup",
+          { err },
+          "Failed to resolve guardian contact; deferring USER.md cleanup",
         );
         return;
       }
-    }
 
-    const userFile = guardian.userFile;
-    if (!userFile || !isValidSlug(userFile)) {
-      log.warn(
-        { userFile },
-        "Guardian userFile is missing or not a safe basename; deferring USER.md cleanup",
-      );
-      return;
-    }
+      if (!guardianRow) {
+        // No local guardian. The mirror can be stale (the gateway mirrors
+        // best-effort), so a customized USER.md may still belong to a real
+        // guardian — preserve it. Only delete the unmodified template/empty
+        // stale file.
+        if (existsSync(userMdPath)) {
+          let isStaleTemplate = false;
+          try {
+            isStaleTemplate =
+              !statSync(userMdPath).isFile() ||
+              isLegacyTemplateContent(readFileSync(userMdPath, "utf-8"));
+          } catch (err) {
+            log.warn(
+              { err, path: userMdPath },
+              "Cannot read USER.md with no guardian; leaving in place",
+            );
+            return;
+          }
+
+          if (!isStaleTemplate) {
+            log.info(
+              { path: userMdPath },
+              "Preserving customized USER.md with no local guardian",
+            );
+            return;
+          }
 
-    const usersDir = join(workspaceDir, "users");
-    mkdirSync(usersDir, { recursive: true });
+          try {
+            unlinkSync(userMdPath);
+            log.info(
+              { path: userMdPath },
+              "Deleting stale template USER.md with no guardian",
+            );
+          } catch (err) {
+            log.warn(
+              { err, path: userMdPath },
+              "Failed to delete stale USER.md; leaving in place",
+            );
+          }
+        }
+        return;
+      }
 
-    const destPath = join(usersDir, userFile);
+      const guardian = {
+        id: guardianRow.id,
+        displayName: guardianRow.display_name,
+        userFile: guardianRow.user_file ?? null,
+      };
 
-    // Read USER.md if it exists and classify its content.
-    let userMdRaw: string | null = null;
-    let userMdIsCustomized = false;
-    if (existsSync(userMdPath)) {
-      try {
-        // Guard against USER.md being a directory (hostile state).
-        if (statSync(userMdPath).isFile()) {
-          userMdRaw = readFileSync(userMdPath, "utf-8");
-          userMdIsCustomized = !isLegacyTemplateContent(userMdRaw);
+      // Backfill a userFile slug on the guardian contact if one isn't set.
+      if (!guardian.userFile) {
+        try {
+          const slug = generateUserFileSlug(db, guardian.displayName);
+          db.run("UPDATE contacts SET user_file = ? WHERE id = ?", [
+            slug,
+            guardian.id,
+          ]);
+          guardian.userFile = slug;
+          log.info(
+            { contactId: guardian.id, slug },
+            "Backfilled missing guardian.userFile",
+          );
+        } catch (err) {
+          log.warn(
+            { err, contactId: guardian.id },
+            "Failed to backfill guardian.userFile; deferring USER.md cleanup",
+          );
+          return;
         }
-      } catch (err) {
-        log.warn(
-          { err, path: userMdPath },
-          "Failed to read USER.md; treating as unreadable",
-        );
       }
-    }
 
-    // Copy customized USER.md content into users/<slug>.md when the
-    // destination is missing or effectively empty. Post-017 installs
-    // that already populated users/<slug>.md are left untouched.
-    if (
-      userMdIsCustomized &&
-      userMdRaw !== null &&
-      destFileIsMissingOrEmpty(destPath)
-    ) {
-      try {
-        copyFileSync(userMdPath, destPath);
-        log.info(
-          { src: userMdPath, dest: destPath },
-          "Copied customized USER.md content into users/<slug>.md",
-        );
-      } catch (err) {
+      const userFile = guardian.userFile;
+      if (!userFile || !isValidSlug(userFile)) {
         log.warn(
-          { err, src: userMdPath, dest: destPath },
-          "Failed to copy USER.md; deferring USER.md cleanup",
+          { userFile },
+          "Guardian userFile is missing or not a safe basename; deferring USER.md cleanup",
         );
         return;
       }
-    }
 
-    // Seed the guardian persona scaffold when the destination file
-    // still doesn't exist (e.g. no USER.md and no post-017 content).
-    // This keeps parity with `ensureGuardianPersonaFile` for new
-    // installs so downstream readers always find a file.
-    if (!existsSync(destPath)) {
-      try {
-        writeFileSync(destPath, GUARDIAN_PERSONA_TEMPLATE, "utf-8");
-        log.info(
-          { dest: destPath },
-          "Seeded guardian persona scaffold at users/<slug>.md",
-        );
-      } catch (err) {
-        log.warn(
-          { err, dest: destPath },
-          "Failed to seed guardian persona scaffold; continuing with USER.md deletion",
-        );
+      const usersDir = join(workspaceDir, "users");
+      mkdirSync(usersDir, { recursive: true });
+
+      const destPath = join(usersDir, userFile);
+
+      // Read USER.md if it exists and classify its content.
+      let userMdRaw: string | null = null;
+      let userMdIsCustomized = false;
+      if (existsSync(userMdPath)) {
+        try {
+          // Guard against USER.md being a directory (hostile state).
+          if (statSync(userMdPath).isFile()) {
+            userMdRaw = readFileSync(userMdPath, "utf-8");
+            userMdIsCustomized = !isLegacyTemplateContent(userMdRaw);
+          }
+        } catch (err) {
+          log.warn(
+            { err, path: userMdPath },
+            "Failed to read USER.md; treating as unreadable",
+          );
+        }
       }
-    }
 
-    // Finally, delete the legacy USER.md if it still exists. Template
-    // or customized, it has no remaining consumer now that PR 11
-    // dropped the seed/fallback read path.
-    if (existsSync(userMdPath)) {
-      try {
-        unlinkSync(userMdPath);
-        log.info({ path: userMdPath }, "Deleted legacy workspace USER.md");
-      } catch (err) {
-        log.warn({ err, path: userMdPath }, "Failed to delete legacy USER.md");
+      // Copy customized USER.md content into users/<slug>.md when the
+      // destination is missing or effectively empty. Post-017 installs
+      // that already populated users/<slug>.md are left untouched.
+      if (
+        userMdIsCustomized &&
+        userMdRaw !== null &&
+        destFileIsMissingOrEmpty(destPath)
+      ) {
+        try {
+          copyFileSync(userMdPath, destPath);
+          log.info(
+            { src: userMdPath, dest: destPath },
+            "Copied customized USER.md content into users/<slug>.md",
+          );
+        } catch (err) {
+          log.warn(
+            { err, src: userMdPath, dest: destPath },
+            "Failed to copy USER.md; deferring USER.md cleanup",
+          );
+          return;
+        }
+      }
+
+      // Seed the guardian persona scaffold when the destination file
+      // still doesn't exist (e.g. no USER.md and no post-017 content).
+      // This keeps parity with `ensureGuardianPersonaFile` for new
+      // installs so downstream readers always find a file.
+      if (!existsSync(destPath)) {
+        try {
+          writeFileSync(destPath, GUARDIAN_PERSONA_TEMPLATE, "utf-8");
+          log.info(
+            { dest: destPath },
+            "Seeded guardian persona scaffold at users/<slug>.md",
+          );
+        } catch (err) {
+          log.warn(
+            { err, dest: destPath },
+            "Failed to seed guardian persona scaffold; continuing with USER.md deletion",
+          );
+        }
+      }
+
+      // Finally, delete the legacy USER.md if it still exists — template or
+      // customized, it has no remaining consumer.
+      if (existsSync(userMdPath)) {
+        try {
+          unlinkSync(userMdPath);
+          log.info({ path: userMdPath }, "Deleted legacy workspace USER.md");
+        } catch (err) {
+          log.warn(
+            { err, path: userMdPath },
+            "Failed to delete legacy USER.md",
+          );
+        }
       }
+    } finally {
+      db.close();
     }
   },
 

package/src/workspace/migrations/048-remove-workspace-hooks.ts

@@ -1,81 +1,29 @@
 /**
- * Workspace migration 046: Remove legacy `workspace/hooks/` directory.
+ * Workspace migration 048: retained no-op.
  *
- * Migration 022 moved `~/.vellum/hooks/` into `$VELLUM_WORKSPACE_DIR/hooks/`.
- * With the hook system entirely removed, that directory is dead state — it is
- * no longer read or written by the assistant. This migration deletes the
- * directory (and everything under it) so stale hook manifests, config, and
- * executables do not linger in user workspaces.
+ * This migration previously deleted `<workspace>/hooks/`, treating it as dead
+ * state. `<workspace>/hooks/` is now a supported surface: standalone hook files
+ * placed there are loaded by the hook loader (see `src/hooks/hook-loader.ts`).
+ * Deleting it would destroy user-authored hooks — including on workspaces that
+ * mount a preseeded `<workspace>/hooks/` before this migration first runs — so
+ * the deletion has been removed.
  *
- * Idempotent: safe to re-run after interruption. A no-op when the directory
- * is already absent.
+ * The migration is kept (rather than removed from the registry) so the applied
+ * checkpoint sequence stays stable across already-migrated workspaces. It is a
+ * no-op on every workspace, new or old.
  */
 
-import { existsSync, readdirSync, rmSync, statSync } 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-048-remove-workspace-hooks");
-
-/**
- * Count files under `dir` recursively. Best-effort — returns the count we
- * could successfully stat, and silently skips entries that fail (e.g. a
- * symlink whose target is missing, a file removed concurrently). This is
- * only used for log output, so a slightly stale count is acceptable.
- */
-function countFilesRecursive(dir: string): number {
-  let count = 0;
-  let entries: string[];
-  try {
-    entries = readdirSync(dir);
-  } catch {
-    return 0;
-  }
-  for (const entry of entries) {
-    const entryPath = join(dir, entry);
-    try {
-      const s = statSync(entryPath);
-      if (s.isDirectory()) {
-        count += countFilesRecursive(entryPath);
-      } else {
-        count += 1;
-      }
-    } catch {
-      // best-effort
-    }
-  }
-  return count;
-}
-
 export const removeWorkspaceHooksMigration: WorkspaceMigration = {
   id: "048-remove-workspace-hooks",
-  description:
-    "Remove legacy workspace/hooks/ directory now that the hook system is gone",
-
-  run(workspaceDir: string): void {
-    const hooksDir = join(workspaceDir, "hooks");
-    if (!existsSync(hooksDir)) return;
+  description: "Retained no-op (workspace/hooks is now a supported surface)",
 
-    const fileCount = countFilesRecursive(hooksDir);
-    try {
-      rmSync(hooksDir, { recursive: true, force: true });
-      log.info(
-        { path: hooksDir, fileCount },
-        "Removed legacy workspace hooks directory",
-      );
-    } catch (err) {
-      log.warn(
-        { err, path: hooksDir },
-        "Failed to remove legacy workspace hooks directory; leaving in place",
-      );
-    }
+  run(_workspaceDir: string): void {
+    // No-op: `<workspace>/hooks/` is a supported surface and must be preserved.
   },
 
   down(_workspaceDir: string): void {
-    // Forward-only: the hook system is gone and the directory contained no
-    // data the assistant still consumes. Restoring an empty directory would
-    // just reintroduce dead state.
+    // No-op: forward-only; nothing to reverse.
   },
 };

package/src/workspace/migrations/111-prune-seeded-callsite-defaults.ts

@@ -0,0 +1,134 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+import type { WorkspaceMigration } from "./types.js";
+
+// Exact system-owned default materializations. These are not user overrides, so
+// matching entries are pruned and resolved through shipped call-site defaults.
+const SEEDED_CALL_SITES: Record<string, Record<string, unknown>> = {
+  guardianQuestionCopy: latencySeed(),
+  interactionClassifier: latencySeed(),
+  skillCategoryInference: latencySeed(),
+  inviteInstructionGenerator: latencySeed(),
+  notificationDecision: latencySeed(),
+  preferenceExtraction: latencySeed(),
+  commitMessage: {
+    model: "claude-haiku-4-5-20251001",
+    maxTokens: 120,
+    temperature: 0.2,
+    effort: "low",
+    thinking: { enabled: false },
+  },
+  conversationStarters: latencySeed(),
+  conversationSummarization: {
+    model: "claude-opus-4-7",
+    effort: "low",
+    thinking: { enabled: false },
+  },
+  recall: {
+    profile: "cost-optimized",
+    maxTokens: 4096,
+    effort: "low",
+    thinking: { enabled: false, streamThinking: false },
+    temperature: 0,
+    disableCache: true,
+  },
+  heartbeatAgent: {
+    profile: "cost-optimized",
+    maxTokens: 2048,
+    effort: "low",
+    temperature: 0,
+    thinking: { enabled: false, streamThinking: false },
+    contextWindow: { maxInputTokens: 16000 },
+  },
+  replySuggestion: {
+    model: "claude-haiku-4-5-20251001",
+    effort: "low",
+    thinking: { enabled: false },
+    disableCache: true,
+  },
+  memoryRouter: {
+    profile: "cost-optimized",
+    contextWindow: { maxInputTokens: 1_000_000 },
+  },
+};
+
+export const pruneSeededCallsiteDefaultsMigration: WorkspaceMigration = {
+  id: "111-prune-seeded-callsite-defaults",
+  description:
+    "Remove seeded LLM call-site default materializations so fresh workspaces show no overrides",
+  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 llm = readObject(config.llm);
+    if (llm === null) return;
+
+    const callSites = readObject(llm.callSites);
+    if (callSites === null) return;
+
+    let changed = false;
+    for (const [callSite, seed] of Object.entries(SEEDED_CALL_SITES)) {
+      if (deepEqual(callSites[callSite], seed)) {
+        delete callSites[callSite];
+        changed = true;
+      }
+    }
+    if (!changed) return;
+
+    if (Object.keys(callSites).length === 0) {
+      delete llm.callSites;
+    } else {
+      llm.callSites = callSites;
+    }
+    config.llm = llm;
+    writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+  },
+  down(_workspaceDir: string): void {
+    // Forward-only: restoring these entries would make defaults appear as
+    // user-visible overrides again.
+  },
+};
+
+function latencySeed(): Record<string, unknown> {
+  return {
+    model: "claude-haiku-4-5-20251001",
+    effort: "low",
+    thinking: { enabled: false },
+  };
+}
+
+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 deepEqual(a: unknown, b: unknown): boolean {
+  if (a === b) return true;
+  if (a === null || b === null) return false;
+  if (typeof a !== "object" || typeof b !== "object") return false;
+  if (Array.isArray(a) || Array.isArray(b)) return false;
+
+  const aRecord = a as Record<string, unknown>;
+  const bRecord = b as Record<string, unknown>;
+  const aKeys = Object.keys(aRecord);
+  const bKeys = Object.keys(bRecord);
+  if (aKeys.length !== bKeys.length) return false;
+
+  for (const key of aKeys) {
+    if (!Object.prototype.hasOwnProperty.call(bRecord, key)) return false;
+    if (!deepEqual(aRecord[key], bRecord[key])) return false;
+  }
+  return true;
+}