@vellumai/assistant 0.10.3-dev.202606271631.97b63cd → 0.10.3-dev.202606271833.9783ef3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.10.3-dev.202606271631.97b63cd",
+  "version": "0.10.3-dev.202606271833.9783ef3",
   "license": "MIT",
   "type": "module",
   "exports": {

package/src/config/schema.ts

@@ -42,6 +42,7 @@ import {
 } from "./schemas/logging.js";
 import { McpConfigSchema } from "./schemas/mcp.js";
 import { MemoryConfigSchema } from "./schemas/memory.js";
+import { MigrationsConfigSchema } from "./schemas/migrations.js";
 import { NotificationsConfigSchema } from "./schemas/notifications.js";
 import {
   DaemonConfigSchema,
@@ -63,6 +64,7 @@ export const AssistantConfigSchema = z
   .object({
     services: ServicesSchema.default(ServicesSchema.parse({})),
     memory: MemoryConfigSchema.default(MemoryConfigSchema.parse({})),
+    migrations: MigrationsConfigSchema.default(MigrationsConfigSchema.parse({})),
     dataDir: z
       .string({ error: "dataDir must be a string" })
       .default(getDataDir())

package/src/config/schemas/migrations.ts

@@ -0,0 +1,25 @@
+import { z } from "zod";
+
+export const MigrationsWorkerConfigSchema = z
+  .object({
+    enabled: z
+      .boolean({ error: "migrations.worker.enabled must be a boolean" })
+      .default(false)
+      .describe(
+        "Enable the async migration worker. While false, migrations that are too expensive to run inside the synchronous startup migration runner skip their work and pass, deferring until the async runner is in place.",
+      ),
+  })
+  .describe("Async migration worker configuration");
+
+export const MigrationsConfigSchema = z
+  .object({
+    worker: MigrationsWorkerConfigSchema.default(
+      MigrationsWorkerConfigSchema.parse({}),
+    ),
+  })
+  .describe("Workspace/database migration configuration");
+
+export type MigrationsWorkerConfig = z.infer<
+  typeof MigrationsWorkerConfigSchema
+>;
+export type MigrationsConfig = z.infer<typeof MigrationsConfigSchema>;

package/src/memory/migrations/209-strip-thinking-from-consolidated.ts

@@ -1,3 +1,4 @@
+import { getConfig } from "../../config/loader.js";
 import { getLogger } from "../../util/logger.js";
 import { getDbPath } from "../../util/platform.js";
 import { runAsyncSqlite } from "../db-async-query.js";
@@ -124,6 +125,19 @@ function windowSql(lo: number, hi: number): string {
 export async function migrateStripThinkingFromConsolidated(
   database: DrizzleDb,
 ): Promise<void> {
+  // Gated on the async migration worker. This sweep proved too expensive for
+  // the synchronous startup migration runner — on a large `messages` table it
+  // can hold the daemon for minutes and trip the startup probe into a restart
+  // loop. While `migrations.worker.enabled` is false, skip the work and let the
+  // step pass so startup is never blocked; performing the sweep is deferred to
+  // the new async migration runner once it takes shape.
+  if (!getConfig().migrations.worker.enabled) {
+    log.info(
+      "Migration 209: skipped — migrations.worker.enabled is false; deferring the strip-thinking sweep to the async migration runner",
+    );
+    return;
+  }
+
   const raw = getSqliteFrom(database);
   const dbPath = getDbPath();
 

package/src/memory/migrations/222-strip-placeholder-sentinels-from-messages.ts

@@ -1,12 +1,16 @@
+import { getConfig } from "../../config/loader.js";
 import {
   PLACEHOLDER_BLOCKS_OMITTED,
   PLACEHOLDER_EMPTY_TURN,
 } from "../../providers/placeholder-sentinels.js";
+import { getLogger } from "../../util/logger.js";
 import { getDbPath } from "../../util/platform.js";
 import { runAsyncSqlite } from "../db-async-query.js";
 import type { DrizzleDb } from "../db-connection.js";
 import { getSqliteFrom } from "../db-connection.js";
 
+const log = getLogger("db-init");
+
 /**
  * Number of `rowid` values swept per `runAsyncSqlite` dispatch. Each window is
  * one off-thread subprocess transaction. Keeping it well below the row count of
@@ -123,6 +127,19 @@ function windowSql(lo: number, hi: number): string {
 export async function migrateStripPlaceholderSentinelsFromMessages(
   database: DrizzleDb,
 ): Promise<void> {
+  // Gated on the async migration worker. This full-table sweep proved too
+  // expensive for the synchronous startup migration runner — on a large
+  // `messages` table it can hold the daemon's event loop and write lock for
+  // minutes. While `migrations.worker.enabled` is false, skip the work and let
+  // the step pass so startup is never blocked; performing the sweep is deferred
+  // to the new async migration runner once it takes shape.
+  if (!getConfig().migrations.worker.enabled) {
+    log.info(
+      "Migration 222: skipped — migrations.worker.enabled is false; deferring the placeholder-sentinel sweep to the async migration runner",
+    );
+    return;
+  }
+
   const raw = getSqliteFrom(database);
   const dbPath = getDbPath();
 

package/src/memory/migrations/__tests__/209-strip-thinking-from-consolidated.test.ts

@@ -17,9 +17,18 @@ const {
   ROWID_WINDOW,
   WINDOW_TIMEOUT_MS,
 } = await import("../209-strip-thinking-from-consolidated.js");
+const { loadRawConfig, saveRawConfig } =
+  await import("../../../config/loader.js");
 
 await initializeDb();
 
+// The sweep is gated behind `migrations.worker.enabled` (default false), under
+// which it short-circuits and passes. Enable it so the migration does its work
+// for these tests.
+const rawConfig = loadRawConfig();
+rawConfig.migrations = { worker: { enabled: true } };
+saveRawConfig(rawConfig);
+
 const CONV = "conv-209";
 getSqlite()
   .query(
@@ -283,6 +292,28 @@ describe("migration 209 — strip thinking from consolidated assistant messages"
     expect(watermark()).toBeNull();
   });
 
+  test("skips the sweep and passes when migrations.worker.enabled is false", async () => {
+    const original = JSON.stringify([
+      { type: "thinking", thinking: "secret", signature: "s" },
+      { type: "text", text: "gated" },
+    ]);
+    const { id } = insert("assistant", original);
+
+    const disabled = loadRawConfig();
+    disabled.migrations = { worker: { enabled: false } };
+    saveRawConfig(disabled);
+    try {
+      // Resolves without throwing and leaves the row untouched — the work is
+      // deferred to the async migration runner.
+      await migrateStripThinkingFromConsolidated(getDb());
+      expect(content(id)).toBe(original);
+    } finally {
+      const enabled = loadRawConfig();
+      enabled.migrations = { worker: { enabled: true } };
+      saveRawConfig(enabled);
+    }
+  });
+
   test("keeps the sweep window and timeout bounded so it cannot overrun a whole table", () => {
     // Regression guard: ROWID_WINDOW was 100_000, larger than a typical
     // messages table, so the entire table swept in one subprocess that overran

package/src/memory/migrations/__tests__/222-strip-placeholder-sentinels-from-messages.test.ts

@@ -20,9 +20,18 @@ const {
   ROWID_WINDOW,
   WINDOW_TIMEOUT_MS,
 } = await import("../222-strip-placeholder-sentinels-from-messages.js");
+const { loadRawConfig, saveRawConfig } =
+  await import("../../../config/loader.js");
 
 await initializeDb();
 
+// The sweep is gated behind `migrations.worker.enabled` (default false), under
+// which it short-circuits and passes. Enable it so the migration does its work
+// for these tests.
+const rawConfig = loadRawConfig();
+rawConfig.migrations = { worker: { enabled: true } };
+saveRawConfig(rawConfig);
+
 const CONV = "conv-222";
 getSqlite()
   .query(
@@ -235,6 +244,28 @@ describe("migration 222 — strip placeholder sentinels from assistant messages"
     expect(blocks(second.id)).toEqual([{ type: "text", text: "second" }]);
   });
 
+  test("skips the sweep and passes when migrations.worker.enabled is false", async () => {
+    const original = JSON.stringify([
+      { type: "text", text: PLACEHOLDER_EMPTY_TURN },
+      { type: "text", text: "gated" },
+    ]);
+    const { id } = insert("assistant", original);
+
+    const disabled = loadRawConfig();
+    disabled.migrations = { worker: { enabled: false } };
+    saveRawConfig(disabled);
+    try {
+      // Resolves without throwing and leaves the row untouched — the work is
+      // deferred to the async migration runner.
+      await migrateStripPlaceholderSentinelsFromMessages(getDb());
+      expect(content(id)).toBe(original);
+    } finally {
+      const enabled = loadRawConfig();
+      enabled.migrations = { worker: { enabled: true } };
+      saveRawConfig(enabled);
+    }
+  });
+
   test("keeps the sweep window and timeout bounded so it cannot overrun a whole table", () => {
     expect(ROWID_WINDOW).toBeLessThanOrEqual(10_000);
     expect(WINDOW_TIMEOUT_MS).toBeLessThan(60 * 60 * 1000);