@vellumai/assistant 0.8.0 → 0.8.2

package/src/workspace/migrations/runner.ts

@@ -3,7 +3,11 @@ import { dirname, join } from "node:path";
 
 import { ensureDir, readTextFileSync } from "../../util/fs.js";
 import { getLogger } from "../../util/logger.js";
-import type { WorkspaceMigration, WorkspaceMigrationStatus } from "./types.js";
+import type {
+  MigrationRunContext,
+  WorkspaceMigration,
+  WorkspaceMigrationStatus,
+} from "./types.js";
 
 const log = getLogger("workspace-migrations");
 
@@ -18,6 +22,13 @@ export type CheckpointFile = {
     string,
     { appliedAt: string; status?: WorkspaceMigrationStatus }
   >;
+  /** Persisted "fresh workspace" flag. Set to `true` by the runner when the
+   *  checkpoint file is being created for the first time; cleared after the
+   *  initial migration sweep finishes. Survives crashes mid-first-boot so
+   *  seeding migrations that fall later in the sequence still observe the
+   *  brand-new state. Absent on workspaces that pre-date this field — those
+   *  are treated as not-new. */
+  isNewWorkspace?: boolean;
 };
 
 function getCheckpointPath(workspaceDir: string): string {
@@ -68,15 +79,28 @@ export async function runWorkspaceMigrations(
   workspaceDir: string,
   migrations: WorkspaceMigration[],
 ): Promise<void> {
-  const seen = new Set<string>();
+  const migrationsById = new Map<string, WorkspaceMigration>();
   for (const m of migrations) {
-    if (seen.has(m.id)) {
+    if (migrationsById.has(m.id)) {
       throw new Error(`Duplicate workspace migration id: "${m.id}"`);
     }
-    seen.add(m.id);
+    migrationsById.set(m.id, m);
   }
 
+  // The checkpoint file is written *before* each migration's run() (to record
+  // the "started" status), so file-absence alone cannot be used to detect a
+  // brand-new workspace — a crash mid-first-boot would flip the next boot's
+  // verdict to "upgrade" before later seeding migrations have run. Persist
+  // the flag inside the file instead so it survives across reboots.
+  const checkpointExisted =
+    readTextFileSync(getCheckpointPath(workspaceDir)) != null;
   const checkpoints = loadCheckpoints(workspaceDir);
+  if (!checkpointExisted) {
+    checkpoints.isNewWorkspace = true;
+  }
+  const ctx: MigrationRunContext = {
+    isNewWorkspace: checkpoints.isNewWorkspace === true,
+  };
 
   for (const [id, entry] of Object.entries(checkpoints.applied)) {
     if (entry.status === "started" || entry.status === "rolling_back") {
@@ -84,6 +108,14 @@ export async function runWorkspaceMigrations(
         `Workspace migration "${id}" was interrupted during a previous run; will re-run`,
       );
       delete checkpoints.applied[id];
+    } else if (
+      entry.status === "failed" &&
+      migrationsById.get(id)?.retryFailedCheckpoint === true
+    ) {
+      log.warn(
+        `Workspace migration "${id}" failed during a previous run; will retry`,
+      );
+      delete checkpoints.applied[id];
     }
   }
 
@@ -104,7 +136,7 @@ export async function runWorkspaceMigrations(
     saveCheckpoints(workspaceDir, checkpoints);
 
     try {
-      await migration.run(workspaceDir);
+      await migration.run(workspaceDir, ctx);
     } catch (error) {
       log.error(
         { migrationId: migration.id, error },
@@ -125,6 +157,15 @@ export async function runWorkspaceMigrations(
     };
     saveCheckpoints(workspaceDir, checkpoints);
   }
+
+  // First-boot sweep finished cleanly — clear the flag so future runs (and
+  // future seeding migrations added later) treat the workspace as an upgrade.
+  // A crash above this point leaves the flag set, so the retry on the next
+  // boot still observes a fresh workspace.
+  if (checkpoints.isNewWorkspace === true) {
+    checkpoints.isNewWorkspace = false;
+    saveCheckpoints(workspaceDir, checkpoints);
+  }
 }
 
 /**

package/src/workspace/migrations/types.ts

@@ -1,13 +1,27 @@
+/** Runtime context passed to each migration's `run()`.
+ *  Lets seeding migrations distinguish a brand-new workspace from a workspace
+ *  upgrading through this migration for the first time. */
+export interface MigrationRunContext {
+  /** True when no workspace-migration checkpoint file existed at the start of
+   *  this run — i.e., this is a freshly-created workspace, not an upgrade. */
+  isNewWorkspace: boolean;
+}
+
 export interface WorkspaceMigration {
   /** Unique identifier, e.g. "001-avatar-rename". Used as the checkpoint key.
    *  Must be unique across all registered migrations — the runner validates this at startup. */
   id: string;
   /** Human-readable description for logging. */
   description: string;
-  /** The migration function. Receives the workspace directory path.
-   *  Must be idempotent — safe to re-run if it was interrupted.
+  /** The migration function. Receives the workspace directory path and an
+   *  optional context object (always supplied by the runner; tests may omit
+   *  it). Must be idempotent — safe to re-run if it was interrupted.
    *  Both synchronous and asynchronous migrations are supported. */
-  run(workspaceDir: string): void | Promise<void>;
+  run(workspaceDir: string, ctx?: MigrationRunContext): void | Promise<void>;
+  /** Retry a prior failed checkpoint on the next run.
+   *  Only set this for migrations whose run() is safe to retry after a
+   *  partially successful failed attempt. */
+  retryFailedCheckpoint?: boolean;
   /** Reverse the migration. Receives the workspace directory path.
    *  Must be idempotent — safe to re-run if it was interrupted.
    *  Both synchronous and asynchronous rollbacks are supported. */

package/src/workspace/provider-commit-message-generator.ts

@@ -1,3 +1,4 @@
+import { resolveCallSiteConfig } from "../config/llm-resolver.js";
 import { getConfig } from "../config/loader.js";
 import { resolveConfiguredProvider } from "../providers/provider-send-message.js";
 import type { Message } from "../providers/types.js";
@@ -45,7 +46,7 @@ const KEYLESS_PROVIDERS = new Set(["ollama"]);
 const deterministicProvider = new DefaultCommitMessageProvider();
 
 function getProviderCandidates(config: ReturnType<typeof getConfig>): string[] {
-  return [config.llm.default.provider];
+  return [resolveCallSiteConfig("commitMessage", config.llm).provider];
 }
 
 function buildDeterministicResult(
@@ -146,7 +147,7 @@ class ProviderCommitMessageGenerator {
         return buildDeterministicResult(context, "missing_provider_api_key");
       }
       log.debug(
-        { provider: config.llm.default.provider },
+        { provider: resolveCallSiteConfig("commitMessage", config.llm).provider },
         "Provider not initialized; falling back to deterministic",
       );
       return buildDeterministicResult(context, "provider_not_initialized");

package/examples/plugins/echo/bun.lock

@@ -1,25 +0,0 @@
-{
-  "lockfileVersion": 1,
-  "configVersion": 1,
-  "workspaces": {
-    "": {
-      "name": "@vellumai/plugin-echo-example",
-      "devDependencies": {
-        "@types/bun": "1.3.10",
-        "@types/node": "25.5.0",
-        "typescript": "5.9.3",
-      },
-    },
-  },
-  "packages": {
-    "@types/bun": ["@types/bun@1.3.10", "", { "dependencies": { "bun-types": "1.3.10" } }, "sha512-0+rlrUrOrTSskibryHbvQkDOWRJwJZqZlxrUs1u4oOoTln8+WIXBPmAuCF35SWB2z4Zl3E84Nl/D0P7803nigQ=="],
-
-    "@types/node": ["@types/node@25.5.0", "", { "dependencies": { "undici-types": "~7.18.0" } }, "sha512-jp2P3tQMSxWugkCUKLRPVUpGaL5MVFwF8RDuSRztfwgN1wmqJeMSbKlnEtQqU8UrhTmzEmZdu2I6v2dpp7XIxw=="],
-
-    "bun-types": ["bun-types@1.3.10", "", { "dependencies": { "@types/node": "*" } }, "sha512-tcpfCCl6XWo6nCVnpcVrxQ+9AYN1iqMIzgrSKYMB/fjLtV2eyAVEg7AxQJuCq/26R6HpKWykQXuSOq/21RYcbg=="],
-
-    "typescript": ["typescript@5.9.3", "", { "bin": { "tsc": "bin/tsc", "tsserver": "bin/tsserver" } }, "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw=="],
-
-    "undici-types": ["undici-types@7.18.2", "", {}, "sha512-AsuCzffGHJybSaRrmr5eHr81mwJU3kjw6M+uprWvCXiNeN9SOGwQ3Jn8jb8m3Z6izVgknn1R0FTCEAP2QrLY/w=="],
-  }
-}

package/src/__tests__/context-search-pkb-source.test.ts

@@ -1,498 +0,0 @@
-import {
-  mkdirSync,
-  mkdtempSync,
-  realpathSync,
-  rmSync,
-  writeFileSync,
-} from "node:fs";
-import { tmpdir } from "node:os";
-import { dirname, join } from "node:path";
-import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
-
-import type { AssistantConfig } from "../config/schema.js";
-import type { RecallSearchContext } from "../memory/context-search/types.js";
-import { PKB_WORKSPACE_SCOPE } from "../memory/pkb/types.js";
-import { makeMockLogger } from "./helpers/mock-logger.js";
-
-mock.module("../util/logger.js", () => ({
-  getLogger: () => makeMockLogger(),
-}));
-
-// Override `getConfig` so `searchPkbFiles`'s v2 short-circuit (which checks
-// `getConfig().memory.v2.enabled`) stays inactive — these tests exercise
-// the v1 path. Spread the real loader so other exports (loadConfig,
-// applyNestedDefaults, etc.) keep working.
-const realPkbLoader = await import("../config/loader.js");
-mock.module("../config/loader.js", () => ({
-  ...realPkbLoader,
-  getConfig: () => ({ memory: { v2: { enabled: false } } }),
-}));
-
-const embedCalls: Array<{
-  config: AssistantConfig;
-  texts: unknown[];
-  opts?: { signal?: AbortSignal };
-}> = [];
-let embedVectors: number[][] = [[0.1, 0.2, 0.3]];
-let embedThrows: Error | null = null;
-
-mock.module("../memory/embed.js", () => ({
-  embedWithRetry: async (
-    config: AssistantConfig,
-    texts: unknown[],
-    opts?: { signal?: AbortSignal },
-  ) => {
-    embedCalls.push({ config, texts, opts });
-    if (embedThrows) throw embedThrows;
-    return { vectors: embedVectors, provider: "test", model: "test-model" };
-  },
-}));
-
-const sparseCalls: string[] = [];
-let sparseVector = { indices: [1], values: [1] };
-
-mock.module("../memory/embedding-backend.js", () => ({
-  clearEmbeddingBackendCache: () => {},
-  embedWithBackend: async () => ({
-    vectors: [],
-    provider: "test",
-    model: "test-model",
-  }),
-  generateSparseEmbedding: (text: string) => {
-    sparseCalls.push(text);
-    return sparseVector;
-  },
-  getMemoryBackendStatus: async () => ({
-    provider: "test",
-    model: "test-model",
-    available: true,
-  }),
-  logMemoryEmbeddingWarning: () => {},
-  resetLocalEmbeddingFailureState: () => {},
-  selectEmbeddingBackend: async () => ({
-    backend: {
-      provider: "test",
-      model: "test-model",
-      embed: async () => [],
-    },
-    provider: "test",
-    model: "test-model",
-  }),
-  selectedBackendSupportsMultimodal: async () => false,
-  SPARSE_EMBEDDING_VERSION: 2,
-}));
-
-type ScoredPoint = {
-  id: string;
-  score: number;
-  payload: {
-    target_type: "pkb_file";
-    target_id: string;
-    path: string;
-    text?: string;
-  };
-};
-
-const qdrantSearchCalls: Array<{
-  vector: number[];
-  limit: number;
-  filter?: unknown;
-}> = [];
-const hybridSearchCalls: Array<{
-  denseVector: number[];
-  sparseVector: { indices: number[]; values: number[] };
-  filter?: unknown;
-  limit: number;
-  prefetchLimit?: number;
-}> = [];
-let denseResults: ScoredPoint[] = [];
-let hybridResults: ScoredPoint[] = [];
-let denseThrows: Error | null = null;
-
-mock.module("../memory/qdrant-circuit-breaker.js", () => ({
-  QdrantCircuitOpenError: class extends Error {},
-  _resetQdrantBreaker: () => {},
-  isQdrantBreakerOpen: () => false,
-  shouldAllowQdrantProbe: () => true,
-  withQdrantBreaker: async <T>(fn: () => Promise<T>): Promise<T> => fn(),
-}));
-
-mock.module("../memory/qdrant-client.js", () => ({
-  getQdrantClient: () => ({
-    search: async (
-      vector: number[],
-      limit: number,
-      filter?: Record<string, unknown>,
-    ) => {
-      qdrantSearchCalls.push({ vector, limit, filter });
-      if (denseThrows) throw denseThrows;
-      return denseResults;
-    },
-    hybridSearch: async (params: {
-      denseVector: number[];
-      sparseVector: { indices: number[]; values: number[] };
-      filter?: unknown;
-      limit: number;
-      prefetchLimit?: number;
-    }) => {
-      hybridSearchCalls.push(params);
-      return hybridResults;
-    },
-  }),
-  initQdrantClient: () => {},
-  resolveQdrantUrl: () => "http://127.0.0.1:6333",
-  VellumQdrantClient: class {},
-}));
-
-let pkbContext: string | null = null;
-let nowScratchpad: string | null = null;
-
-mock.module("../daemon/conversation-runtime-assembly.js", () => ({
-  readPkbContext: () => pkbContext,
-  readNowScratchpad: () => nowScratchpad,
-}));
-
-const { readPkbContextEvidence, searchPkbSource } =
-  await import("../memory/context-search/sources/pkb.js");
-
-const testDirs: string[] = [];
-
-afterEach(() => {
-  for (const dir of testDirs.splice(0)) {
-    rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-function makeTempDir(): string {
-  const dir = realpathSync(
-    mkdtempSync(join(tmpdir(), "context-search-pkb-source-")),
-  );
-  testDirs.push(dir);
-  return dir;
-}
-
-function writeWorkspaceFile(root: string, relativePath: string, text: string) {
-  const filePath = join(root, relativePath);
-  mkdirSync(dirname(filePath), { recursive: true });
-  writeFileSync(filePath, text);
-}
-
-function makeContext(
-  overrides: Partial<RecallSearchContext> = {},
-): RecallSearchContext {
-  return {
-    workingDir: "/workspace",
-    conversationId: "conv-xyz",
-    config: { memory: { v2: { enabled: false } } } as AssistantConfig,
-    ...overrides,
-  };
-}
-
-describe("PKB context-search source", () => {
-  beforeEach(() => {
-    embedCalls.length = 0;
-    embedVectors = [[0.1, 0.2, 0.3]];
-    embedThrows = null;
-    sparseCalls.length = 0;
-    sparseVector = { indices: [1], values: [1] };
-    qdrantSearchCalls.length = 0;
-    hybridSearchCalls.length = 0;
-    denseResults = [];
-    hybridResults = [];
-    denseThrows = null;
-    pkbContext = null;
-    nowScratchpad = null;
-  });
-
-  test("converts PKB hits to recall evidence with snippets and scores", async () => {
-    denseResults = [
-      {
-        id: "dense-a",
-        score: 0.82,
-        payload: {
-          target_type: "pkb_file",
-          target_id: "a",
-          path: "notes/project.md",
-          text: "Dense project notes.",
-        },
-      },
-      {
-        id: "dense-b",
-        score: 0.71,
-        payload: {
-          target_type: "pkb_file",
-          target_id: "b",
-          path: "notes/fallback.md",
-        },
-      },
-    ];
-    hybridResults = [
-      {
-        id: "hybrid-a",
-        score: 0.04,
-        payload: {
-          target_type: "pkb_file",
-          target_id: "a",
-          path: "notes/project.md",
-          text: "Project notes mention the launch checklist.",
-        },
-      },
-    ];
-
-    const result = await searchPkbSource("launch checklist", makeContext(), 2);
-
-    expect(embedCalls[0]?.texts).toEqual(["launch checklist"]);
-    expect(sparseCalls).toEqual(["launch checklist"]);
-    expect(result.evidence).toEqual([
-      {
-        id: "pkb:notes/project.md:0",
-        source: "pkb",
-        title: "notes/project.md",
-        locator: "notes/project.md",
-        excerpt: "Project notes mention the launch checklist.",
-        score: 0.04,
-        metadata: {
-          path: "notes/project.md",
-          denseScore: 0.82,
-          hybridScore: 0.04,
-        },
-      },
-      {
-        id: "pkb:notes/fallback.md:1",
-        source: "pkb",
-        title: "notes/fallback.md",
-        locator: "notes/fallback.md",
-        excerpt: "notes/fallback.md",
-        score: 0.71,
-        metadata: {
-          path: "notes/fallback.md",
-          denseScore: 0.71,
-        },
-      },
-    ]);
-  });
-
-  test("uses the PKB workspace sentinel scope instead of the active context scope", async () => {
-    denseResults = [
-      {
-        id: "a",
-        score: 0.8,
-        payload: {
-          target_type: "pkb_file",
-          target_id: "a",
-          path: "notes/a.md",
-        },
-      },
-    ];
-
-    await searchPkbSource("notes", makeContext(), 5);
-
-    expect(qdrantSearchCalls).toHaveLength(1);
-    const filter = qdrantSearchCalls[0]?.filter as {
-      must: Array<Record<string, unknown>>;
-    };
-    const scopeClause = filter.must.find(
-      (clause) => clause.key === "memory_scope_id",
-    ) as { match: { any: string[] } } | undefined;
-    expect(scopeClause?.match.any).toEqual([PKB_WORKSPACE_SCOPE]);
-    expect(scopeClause?.match.any).not.toContain("active-conversation-scope");
-  });
-
-  test("returns empty evidence when embedding has no vector", async () => {
-    embedVectors = [];
-
-    const result = await searchPkbSource("notes", makeContext(), 5);
-
-    expect(result).toEqual({ evidence: [] });
-    expect(qdrantSearchCalls).toHaveLength(0);
-  });
-
-  test("falls back to empty evidence when PKB search fails", async () => {
-    denseThrows = new Error("qdrant unavailable");
-
-    const result = await searchPkbSource("notes", makeContext(), 5);
-
-    expect(result).toEqual({ evidence: [] });
-  });
-
-  test("uses lexical PKB fallback when semantic search returns no hits", async () => {
-    const root = makeTempDir();
-    embedVectors = [];
-    writeWorkspaceFile(
-      root,
-      "pkb/archive/2026-04-07.md",
-      [
-        "# Apr 7",
-        "- The birthday cake was fully paid. Gold design, vanilla with raspberry filling, and inscription Happy birthday Alice Love Example Assistant.",
-        "- Other notes.",
-      ].join("\n"),
-    );
-
-    const result = await searchPkbSource(
-      "details about the birthday cake flavor decoration message recipient",
-      makeContext({ workingDir: root }),
-      5,
-    );
-
-    expect(result.evidence[0]).toMatchObject({
-      id: "pkb:lexical:archive/2026-04-07.md:2",
-      source: "pkb",
-      title: "archive/2026-04-07.md",
-      locator: "archive/2026-04-07.md:2",
-      metadata: {
-        retrieval: "lexical",
-        matchedTerms: ["birthday", "cake"],
-      },
-    });
-    expect(result.evidence[0]?.excerpt).toContain("vanilla with raspberry");
-  });
-
-  test("lexical PKB fallback finds declarative residence facts", async () => {
-    const root = makeTempDir();
-    embedVectors = [];
-    writeWorkspaceFile(
-      root,
-      "pkb/people/alice.md",
-      [
-        "# Alice",
-        "",
-        "Notes about family geography.",
-        "",
-        "- Lives at Bob's parents' house in Katy and has her own room.",
-      ].join("\n"),
-    );
-
-    const result = await searchPkbSource(
-      "alice lives residence home location address",
-      makeContext({ workingDir: root }),
-      5,
-    );
-
-    expect(result.evidence[0]).toMatchObject({
-      id: "pkb:lexical:people/alice.md:5",
-      source: "pkb",
-      title: "people/alice.md",
-      locator: "people/alice.md:5",
-      metadata: {
-        retrieval: "lexical",
-        matchedTerms: ["lives"],
-      },
-    });
-    expect(result.evidence[0]?.excerpt).toContain(
-      "Lives at Bob's parents' house in Katy",
-    );
-  });
-
-  test("lexical PKB fallback preserves the matched line when context is long", async () => {
-    const root = makeTempDir();
-    embedVectors = [];
-    writeWorkspaceFile(
-      root,
-      "pkb/archive/notes.md",
-      [`prefix ${"x".repeat(900)}`, "needle final detail", "tail"].join("\n"),
-    );
-
-    const result = await searchPkbSource(
-      "needle",
-      makeContext({ workingDir: root }),
-      5,
-    );
-
-    expect(result.evidence[0]?.excerpt).toBe("2: needle final detail");
-  });
-
-  test("returns lexical PKB evidence when Qdrant is unavailable", async () => {
-    const root = makeTempDir();
-    denseThrows = new Error("qdrant unavailable");
-    writeWorkspaceFile(
-      root,
-      "pkb/people/bob.md",
-      "Bob asked whether the cake was Alice's way of sending something into the room.",
-    );
-
-    const result = await searchPkbSource(
-      "the cake Bob asked about",
-      makeContext({ workingDir: root }),
-      5,
-    );
-
-    expect(result.evidence.map((item) => item.locator)).toEqual([
-      "people/bob.md:1",
-    ]);
-  });
-
-  test("returns no static PKB evidence when injected context is missing", () => {
-    expect(readPkbContextEvidence(makeContext())).toEqual([]);
-  });
-
-  test("returns PKB auto-inject and NOW evidence when present", () => {
-    pkbContext = "Always include the product glossary.";
-    nowScratchpad = "Current priority: finish the launch checklist.";
-
-    const evidence = readPkbContextEvidence(makeContext());
-
-    expect(evidence).toEqual([
-      {
-        id: "pkb:auto-inject",
-        source: "pkb",
-        title: "PKB auto-injected context",
-        locator: "pkb:auto-inject",
-        excerpt: "Always include the product glossary.",
-        metadata: { kind: "auto-inject" },
-      },
-      {
-        id: "pkb:NOW.md",
-        source: "pkb",
-        title: "NOW.md",
-        locator: "NOW.md",
-        excerpt: "Current priority: finish the launch checklist.",
-        metadata: { kind: "now" },
-      },
-    ]);
-  });
-
-  test("short-circuits to empty when memory.v2.enabled is on", async () => {
-    denseResults = [
-      {
-        id: "dense-a",
-        score: 0.9,
-        payload: {
-          target_type: "pkb_file",
-          target_id: "a",
-          path: "notes/should-not-appear.md",
-          text: "should not appear",
-        },
-      },
-    ];
-
-    const result = await searchPkbSource(
-      "anything",
-      makeContext({ config: makeV2EnabledConfig() }),
-      5,
-    );
-
-    expect(result).toEqual({ evidence: [] });
-    expect(qdrantSearchCalls).toHaveLength(0);
-    expect(hybridSearchCalls).toHaveLength(0);
-    expect(embedCalls).toHaveLength(0);
-  });
-
-  test("readPkbContextEvidence short-circuits when v2 read is active", () => {
-    pkbContext = "should not surface under v2";
-    nowScratchpad = "should not surface under v2";
-
-    const evidence = readPkbContextEvidence(
-      makeContext({ config: makeV2EnabledConfig() }),
-    );
-
-    expect(evidence).toEqual([]);
-  });
-});
-
-function makeV2EnabledConfig(): AssistantConfig {
-  return {
-    memory: {
-      v2: { enabled: true },
-    },
-  } as unknown as AssistantConfig;
-}