@vellumai/assistant 0.8.0 → 0.8.1

package/src/workspace/migrations/074-drop-deprecated-secret-detection-keys.ts

@@ -0,0 +1,117 @@
+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-074-drop-deprecated-secret-detection-keys",
+);
+
+const MIGRATION_ID = "074-drop-deprecated-secret-detection-keys";
+const NOTICE_MARKER = `<!-- release-note-id:${MIGRATION_ID} -->`;
+
+function buildNotice(previousAction: string): string {
+  return `${NOTICE_MARKER}
+## Heads-up: tool-output secret scanning was retired
+
+Your previous \`secretDetection.action\` setting was \`"${previousAction}"\`,
+which used to gate or redact tool output containing high-entropy strings or
+matches against custom regex patterns. That post-execution scanning layer has
+been removed because it was false-positive prone and prevented the assistant
+from acting on values it had legitimately fetched.
+
+Prefix-based ingress detection on user messages is still active
+(\`secretDetection.enabled\` / \`secretDetection.blockIngress\`), and the
+\`secretDetection.entropyThreshold\` and \`secretDetection.customPatterns\`
+fields have been removed from your config. If you relied on the old behavior,
+please reach out so we can find a better solution for your use case.
+`;
+}
+
+export const dropDeprecatedSecretDetectionKeysMigration: WorkspaceMigration = {
+  id: MIGRATION_ID,
+  description:
+    "Strip removed secretDetection.action / entropyThreshold / customPatterns keys; notify users who had a non-default action policy",
+
+  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 secretDetection = readObject(config.secretDetection);
+    if (secretDetection === null) return;
+
+    const previousAction =
+      typeof secretDetection.action === "string"
+        ? secretDetection.action
+        : null;
+
+    let mutated = false;
+    for (const key of ["action", "entropyThreshold", "customPatterns"]) {
+      if (key in secretDetection) {
+        delete secretDetection[key];
+        mutated = true;
+      }
+    }
+
+    if (mutated) {
+      writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+    }
+
+    if (previousAction === "block" || previousAction === "prompt") {
+      appendNotice(workspaceDir, previousAction);
+    }
+  },
+
+  down(_workspaceDir: string): void {
+    // Forward-only: restoring the deleted keys would re-introduce schema
+    // warnings without changing runtime behavior — the post-execution scanner
+    // they used to drive no longer exists.
+  },
+};
+
+function appendNotice(workspaceDir: string, previousAction: string): void {
+  const updatesPath = join(workspaceDir, "UPDATES.md");
+  const notice = buildNotice(previousAction);
+
+  try {
+    if (existsSync(updatesPath)) {
+      const existing = readFileSync(updatesPath, "utf-8");
+      if (existing.includes(NOTICE_MARKER)) return;
+      const prefix = existing.endsWith("\n") ? "\n" : "\n\n";
+      appendFileSync(updatesPath, `${prefix}${notice}`, "utf-8");
+    } else {
+      writeFileSync(updatesPath, notice, "utf-8");
+    }
+    log.info(
+      { path: updatesPath, previousAction },
+      "Appended secret-detection retirement notice",
+    );
+  } catch (err) {
+    log.warn(
+      { err, path: updatesPath, previousAction },
+      "Failed to append secret-detection retirement notice to UPDATES.md",
+    );
+  }
+}
+
+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>;
+}

package/src/workspace/migrations/075-memory-v2-bm25-b-default-reembed.ts

@@ -0,0 +1,61 @@
+import { randomUUID } from "node:crypto";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { Database } from "bun:sqlite";
+
+import type { WorkspaceMigration } from "./types.js";
+
+/**
+ * Enqueue a one-shot `memory_v2_reembed` job so existing concept pages pick
+ * up the new `memory.v2.bm25_b` default (0.4, lowered from 0.75 in PR
+ * #29345). `embed_concept_page` bakes `bm25_b` into the stored sparse
+ * vectors at write time, so without this nudge workspaces that never pinned
+ * the field would silently mix old and new length normalization until a
+ * manual reembed.
+ */
+export const memoryV2Bm25BDefaultReembedMigration: WorkspaceMigration = {
+  id: "075-memory-v2-bm25-b-default-reembed",
+  description:
+    "Enqueue memory_v2_reembed so existing concept pages pick up the new bm25_b=0.4 default",
+
+  run(workspaceDir: string): void {
+    const dbPath = join(workspaceDir, "data", "db", "assistant.db");
+    if (!existsSync(dbPath)) return; // Fresh install — pages will embed at the new default.
+
+    let db: Database;
+    try {
+      db = new Database(dbPath);
+    } catch {
+      return;
+    }
+
+    try {
+      const tableRow = db
+        .query(
+          `SELECT name FROM sqlite_master WHERE type='table' AND name='memory_jobs'`,
+        )
+        .get();
+      if (!tableRow) return;
+
+      const existing = db
+        .query(
+          `SELECT id FROM memory_jobs WHERE type='memory_v2_reembed' AND status IN ('pending','running') LIMIT 1`,
+        )
+        .get();
+      if (existing) return;
+
+      const now = Date.now();
+      db.query(
+        `INSERT INTO memory_jobs
+           (id, type, payload, status, attempts, deferrals, run_after, last_error, created_at, updated_at)
+         VALUES (?, 'memory_v2_reembed', '{}', 'pending', 0, 0, ?, NULL, ?, ?)`,
+      ).run(randomUUID(), now, now, now);
+    } finally {
+      db.close();
+    }
+  },
+
+  down(_workspaceDir: string): void {
+    // Forward-only: the reembed is a one-shot data refresh.
+  },
+};

package/src/workspace/migrations/076-drop-services-inference-mode.ts

@@ -0,0 +1,62 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+import type { WorkspaceMigration } from "./types.js";
+
+/**
+ * Strip the now-removed `services.inference.mode` field from existing
+ * `config.json` files. The field governed the global `managed` vs `your-own`
+ * routing toggle that was superseded by the `provider_connections` table. Auth
+ * routing is now per-profile via the `provider_connection` reference; there is
+ * no longer a schema-level field to store here.
+ *
+ * If `services.inference` becomes an empty object after stripping, it is left
+ * as `{}` — the schema still expects the key to be present (other code walks
+ * `config.services.inference`).
+ *
+ * Idempotent: re-running when `mode` is already absent is a no-op.
+ */
+export const dropServicesInferenceModeMigration: WorkspaceMigration = {
+  id: "076-drop-services-inference-mode",
+  description:
+    "Strip services.inference.mode from config.json (mode field removed from schema)",
+  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 services = config.services;
+    if (
+      services === null ||
+      typeof services !== "object" ||
+      Array.isArray(services)
+    )
+      return;
+
+    const inference = (services as Record<string, unknown>).inference;
+    if (
+      inference === null ||
+      typeof inference !== "object" ||
+      Array.isArray(inference)
+    )
+      return;
+
+    const inferenceObj = inference as Record<string, unknown>;
+    if (!("mode" in inferenceObj)) return;
+
+    delete inferenceObj.mode;
+    writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+  },
+  down(_workspaceDir: string): void {
+    // Forward-only: re-adding mode would reintroduce a field the schema no
+    // longer recognizes.
+  },
+};

package/src/workspace/migrations/077-seed-memory-router-callsite.ts

@@ -0,0 +1,89 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+import type { WorkspaceMigration } from "./types.js";
+
+/**
+ * Seed `callSites.memoryRouter = { model: "claude-sonnet-4-6",
+ * contextWindow: { maxInputTokens: 1000000 } }` so the per-turn memory
+ * router runs on Sonnet 4.6 with the 1M context window by default.
+ *
+ * The router builds a numbered page index in the system prompt; a 1M
+ * context window keeps every concept page reachable even on large
+ * workspaces, and Sonnet 4.6 is the cheapest 1M-context Anthropic
+ * model that handles the routing task well. Without this seed the
+ * call site would inherit the workspace default model, which may
+ * cap context at 200k and silently truncate the index for large
+ * workspaces.
+ *
+ * Mirrors {@link seedMainAgentOpusCallsiteMigration} (050):
+ *
+ *   1. Existing workspace (config.json present): merge the seed into
+ *      `llm.callSites` without overwriting a user-defined override.
+ *   2. Fresh install (config.json absent): write a minimal starter
+ *      config carrying just the seed; `loadConfig()` applies schema
+ *      defaults to the in-memory config after migrations run.
+ *
+ * Skipped when:
+ *   - `VELLUM_DEFAULT_WORKSPACE_CONFIG_PATH` is set (platform overlay wins),
+ *   - the user already has `llm.callSites.memoryRouter` (any override stays),
+ *   - the resolved provider is non-Anthropic (those workspaces pick their
+ *     own equivalent — we don't know which OpenAI/Gemini/Ollama model the
+ *     operator wants for the routing role).
+ */
+export const seedMemoryRouterCallsiteMigration: WorkspaceMigration = {
+  id: "077-seed-memory-router-callsite",
+  description:
+    "Seed callSites.memoryRouter to claude-sonnet-4-6 + 1M context for Anthropic",
+  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 explicitProvider = readString(defaultBlock?.provider);
+    if (explicitProvider !== undefined && explicitProvider !== "anthropic") {
+      return;
+    }
+
+    const callSites = readObject(llm.callSites) ?? {};
+    if (readObject(callSites.memoryRouter) !== null) return;
+
+    callSites.memoryRouter = {
+      model: "claude-sonnet-4-6",
+      contextWindow: { maxInputTokens: 1_000_000 },
+    };
+    llm.callSites = callSites;
+    config.llm = llm;
+    writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+  },
+  down(_workspaceDir: string): void {
+    // Forward-only: removing the seed would downgrade the router to the
+    // workspace default model on every re-run, defeating the goal.
+  },
+};
+
+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/078-release-notes-tavily-web-search.ts

@@ -0,0 +1,66 @@
+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-078-release-notes-tavily-web-search",
+);
+
+const MIGRATION_ID = "078-release-notes-tavily-web-search";
+const MARKER = `<!-- release-note-id:${MIGRATION_ID} -->`;
+
+const RELEASE_NOTE = `${MARKER}
+## Tavily web search
+
+Tavily is now available as a web search provider. Add your Tavily API key in
+Settings → Models & Services, or run \`assistant keys set tavily <key>\`, then
+select Tavily for Web Search.
+`;
+
+export const releaseNotesTavilyWebSearchMigration: WorkspaceMigration = {
+  id: MIGRATION_ID,
+  description: "Append release notes for Tavily web search 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 Tavily web search release note",
+      );
+    } catch (err) {
+      log.warn(
+        { err, path: updatesPath },
+        "Failed to append Tavily web search 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/079-home-feed-notification-only.ts

@@ -0,0 +1,197 @@
+/**
+ * Workspace migration `076-home-feed-notification-only`.
+ *
+ * Rewrites `<workspace>/data/home-feed.json` from the legacy v1 schema
+ * (mixed `nudge | digest | action | thread` types with `source`,
+ * `author`, `minTimeAway` fields) into the collapsed v2 schema (single
+ * `notification` type, no source/author/minTimeAway).
+ *
+ * Behaviour:
+ *   - Missing file → no-op.
+ *   - Malformed JSON → log and no-op (daemon startup must never block;
+ *     the writer's `readHomeFeed()` already treats unreadable files as
+ *     empty so the next append cycle naturally rewrites a clean file).
+ *   - Already v2 → no-op (idempotent).
+ *   - v1 (or any non-v2 shape with an `items` array): drop entries
+ *     whose `type !== "action"` (legacy nudge/digest/thread items have
+ *     no v2 analogue and weren't surfaced as live notifications anyway,
+ *     per PR 15 of the home-notif-feed-revamp plan); for kept entries
+ *     drop `source` / `author` / `minTimeAway` and rewrite `type` to
+ *     `"notification"`. Persist as `{ version: 2, items, updatedAt }`.
+ *
+ * Idempotent: running the migration a second time on a v2 file is a
+ * no-op. The runner's checkpoint also skips re-runs, but this in-file
+ * guard keeps the migration safe even if the checkpoint is wiped.
+ *
+ * `down()` is a no-op — the legacy v1 fields (`source`, `author`,
+ * `minTimeAway`, the four item types) were dropped during the
+ * forward migration and cannot be recovered. Rolling back to v1 from
+ * v2 would also leave the writer producing a shape the older code
+ * cannot parse, so a real rollback would require reverting the writer
+ * code in lockstep.
+ */
+
+import { 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-076-home-feed-notification-only");
+
+const HOME_FEED_RELATIVE_PATH = join("data", "home-feed.json");
+
+/** v2 file format. Mirrors `HomeFeedFile` in `home/feed-types.ts`. */
+interface V2HomeFeedFile {
+  version: 2;
+  items: V2FeedItem[];
+  updatedAt: string;
+}
+
+/**
+ * v2 item shape. Inlined rather than imported from `home/feed-types.ts`
+ * so the migration stays self-contained — per AGENTS.md migrations
+ * should minimise cross-module coupling so they remain stable as code
+ * around them evolves.
+ */
+interface V2FeedItem {
+  id: string;
+  type: "notification";
+  priority: number;
+  title: string;
+  summary: string;
+  timestamp: string;
+  status: string;
+  expiresAt?: string;
+  actions?: unknown[];
+  urgency?: string;
+  conversationId?: string;
+  detailPanel?: unknown;
+  createdAt: string;
+}
+
+export const homeFeedNotificationOnlyMigration: WorkspaceMigration = {
+  id: "home-feed-notification-only-v2",
+  description:
+    "Rewrite home-feed.json into v2 schema (single 'notification' type)",
+
+  run(workspaceDir: string): void {
+    const path = join(workspaceDir, HOME_FEED_RELATIVE_PATH);
+    if (!existsSync(path)) {
+      return;
+    }
+
+    let raw: unknown;
+    try {
+      raw = JSON.parse(readFileSync(path, "utf-8"));
+    } catch (err) {
+      // Daemon startup must never block on a parse failure here. The
+      // writer's read path also treats malformed files as empty, so
+      // skipping the migration just means the next append cycle will
+      // overwrite the file with a fresh v2 snapshot.
+      log.warn(
+        { err, path },
+        "Failed to parse home-feed.json; skipping migration",
+      );
+      return;
+    }
+
+    if (!isPlainObject(raw)) {
+      log.warn({ path }, "home-feed.json is not an object; skipping migration");
+      return;
+    }
+
+    if (raw.version === 2) {
+      // Already migrated.
+      return;
+    }
+
+    const rawItems = Array.isArray(raw.items) ? raw.items : [];
+    const items: V2FeedItem[] = [];
+    for (const entry of rawItems) {
+      const migrated = migrateItem(entry);
+      if (migrated) items.push(migrated);
+    }
+
+    const next: V2HomeFeedFile = {
+      version: 2,
+      items,
+      updatedAt: new Date().toISOString(),
+    };
+
+    try {
+      writeFileSync(path, JSON.stringify(next, null, 2), "utf-8");
+      log.info(
+        { path, items: items.length },
+        "Rewrote home-feed.json to v2 schema",
+      );
+    } catch (err) {
+      log.warn(
+        { err, path },
+        "Failed to write migrated home-feed.json; leaving prior file in place",
+      );
+    }
+  },
+
+  down(_workspaceDir: string): void {
+    // Lossy migration — legacy fields (source/author/minTimeAway and
+    // nudge/digest/thread items) cannot be reconstructed. The writer
+    // code itself only emits v2 now, so rolling back would also leave
+    // the file in a shape the v1 reader could not parse without
+    // reverting feed-writer.ts in lockstep.
+  },
+};
+
+/**
+ * Convert a single legacy item into a v2 item, or return `null` to
+ * drop it. Only `type === "action"` items survive — legacy
+ * nudge/digest/thread entries have no v2 analogue and were not
+ * surfaced as live notifications by PR 4's wiring (only assistant-
+ * authored `action` items reached the live feed via
+ * `home-feed-side-effect.ts`).
+ */
+function migrateItem(entry: unknown): V2FeedItem | null {
+  if (!isPlainObject(entry)) return null;
+  if (entry.type !== "action") return null;
+
+  // Required fields — fail-soft on missing critical strings rather
+  // than throwing, so a single bad legacy entry does not lose the
+  // rest of the items.
+  if (
+    typeof entry.id !== "string" ||
+    typeof entry.title !== "string" ||
+    typeof entry.summary !== "string" ||
+    typeof entry.timestamp !== "string" ||
+    typeof entry.createdAt !== "string"
+  ) {
+    return null;
+  }
+  const priority =
+    typeof entry.priority === "number" && Number.isInteger(entry.priority)
+      ? entry.priority
+      : 50;
+  const status = typeof entry.status === "string" ? entry.status : "new";
+
+  const out: V2FeedItem = {
+    id: entry.id,
+    type: "notification",
+    priority,
+    title: entry.title,
+    summary: entry.summary,
+    timestamp: entry.timestamp,
+    status,
+    createdAt: entry.createdAt,
+  };
+  if (typeof entry.expiresAt === "string") out.expiresAt = entry.expiresAt;
+  if (Array.isArray(entry.actions)) out.actions = entry.actions;
+  if (typeof entry.urgency === "string") out.urgency = entry.urgency;
+  if (typeof entry.conversationId === "string") {
+    out.conversationId = entry.conversationId;
+  }
+  if (isPlainObject(entry.detailPanel)) out.detailPanel = entry.detailPanel;
+  return out;
+}
+
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}