@vellumai/assistant 0.12.5 → 0.12.6-dev.202609292116.41f7caa

package/src/persistence/conversation-auto-archive.ts

@@ -0,0 +1,170 @@
+import {
+  and,
+  asc,
+  eq,
+  gt,
+  inArray,
+  isNull,
+  lte,
+  notExists,
+  notInArray,
+  or,
+  sql,
+} from "drizzle-orm";
+
+import { ACP_LIVE_STATUSES } from "../acp/types.js";
+import { TERMINAL_STATUSES } from "../subagent/types.js";
+import { unseenAttentionStateConditions } from "./conversation-attention-store.js";
+import { ensureGroupMigration } from "./conversation-group-migration.js";
+import {
+  MEMORY_V2_CONSOLIDATION_SOURCE,
+  NATIVE_ORIGIN_CHANNEL,
+  PINNED_GROUP_ID,
+} from "./conversation-types.js";
+import { getDb } from "./db-connection.js";
+import { rawChanges } from "./raw-query.js";
+import {
+  acpSessionHistory,
+  conversationAssistantAttentionState,
+  conversationModeSessions,
+  conversations,
+  externalConversationBindings,
+  workflowRuns,
+} from "./schema/index.js";
+
+const activityAt = sql<number>`max(coalesce(${conversations.lastMessageAt}, ${conversations.createdAt}), coalesce(${conversations.lastReopenedAt}, ${conversations.createdAt}))`;
+
+export interface AutoArchiveCandidate {
+  id: string;
+  createdAt: number;
+  lastMessageAt: number | null;
+  lastReopenedAt: number | null;
+  activityAt: number;
+}
+
+function eligibleForAutoArchive(cutoff: number) {
+  const db = getDb();
+  const origin = sql`coalesce((select ${externalConversationBindings.sourceChannel} from ${externalConversationBindings} where ${externalConversationBindings.conversationId} = ${conversations.id}), ${conversations.originChannel}, ${NATIVE_ORIGIN_CHANNEL})`;
+  return and(
+    isNull(conversations.archivedAt),
+    isNull(conversations.processingStartedAt),
+    eq(conversations.conversationType, "standard"),
+    notInArray(conversations.source, [
+      "subagent",
+      "system",
+      MEMORY_V2_CONSOLIDATION_SOURCE,
+    ]),
+    isNull(conversations.parentConversationId),
+    isNull(conversations.scheduleJobId),
+    sql`coalesce(group_id, 'system:all') not in (${PINNED_GROUP_ID}, 'system:background', 'system:scheduled')`,
+    or(eq(origin, NATIVE_ORIGIN_CHANNEL), sql`${origin} like 'notification:%'`),
+    lte(activityAt, cutoff),
+    notExists(
+      db
+        .select({ id: conversationAssistantAttentionState.conversationId })
+        .from(conversationAssistantAttentionState)
+        .where(
+          and(
+            eq(
+              conversationAssistantAttentionState.conversationId,
+              conversations.id,
+            ),
+            ...unseenAttentionStateConditions(),
+          ),
+        ),
+    ),
+    notExists(
+      db
+        .select({ id: acpSessionHistory.id })
+        .from(acpSessionHistory)
+        .where(
+          and(
+            eq(acpSessionHistory.parentConversationId, conversations.id),
+            inArray(acpSessionHistory.status, [...ACP_LIVE_STATUSES]),
+          ),
+        ),
+    ),
+    notExists(
+      db
+        .select({ id: workflowRuns.id })
+        .from(workflowRuns)
+        .where(
+          and(
+            eq(workflowRuns.conversationId, conversations.id),
+            eq(workflowRuns.status, "running"),
+          ),
+        ),
+    ),
+    notExists(
+      db
+        .select({ id: conversationModeSessions.id })
+        .from(conversationModeSessions)
+        .where(
+          and(
+            eq(conversationModeSessions.conversationId, conversations.id),
+            eq(conversationModeSessions.status, "active"),
+          ),
+        ),
+    ),
+    sql`not exists (select 1 from subagents where parent_conversation_id = ${conversations.id} and status not in (${sql.join(
+      [...TERMINAL_STATUSES].map((status) => sql`${status}`),
+      sql`, `,
+    )}))`,
+  );
+}
+
+export function listAutoArchiveCandidates(options: {
+  cutoff: number;
+  limit: number;
+  after?: Pick<AutoArchiveCandidate, "activityAt" | "id">;
+}): AutoArchiveCandidate[] {
+  ensureGroupMigration();
+  return getDb()
+    .select({
+      id: conversations.id,
+      createdAt: conversations.createdAt,
+      lastMessageAt: conversations.lastMessageAt,
+      lastReopenedAt: conversations.lastReopenedAt,
+      activityAt,
+    })
+    .from(conversations)
+    .where(
+      and(
+        eligibleForAutoArchive(options.cutoff),
+        options.after
+          ? or(
+              gt(activityAt, options.after.activityAt),
+              and(
+                eq(activityAt, options.after.activityAt),
+                gt(conversations.id, options.after.id),
+              ),
+            )
+          : undefined,
+      ),
+    )
+    .orderBy(asc(activityAt), asc(conversations.id))
+    .limit(options.limit)
+    .all();
+}
+
+/** The sampled cursors and current eligibility are checked by the write itself. */
+export function archiveInactiveConversation(
+  candidate: AutoArchiveCandidate,
+  cutoff: number,
+  archivedAt: number,
+): boolean {
+  getDb()
+    .update(conversations)
+    .set({ archivedAt, updatedAt: archivedAt })
+    .where(
+      and(
+        eq(conversations.id, candidate.id),
+        eq(conversations.createdAt, candidate.createdAt),
+        sql`${conversations.lastMessageAt} is ${candidate.lastMessageAt}`,
+        sql`${conversations.lastReopenedAt} is ${candidate.lastReopenedAt}`,
+        eligibleForAutoArchive(cutoff),
+      ),
+    )
+    .run();
+  return rawChanges() > 0;
+}

package/src/persistence/conversation-crud.ts

@@ -3594,7 +3594,8 @@ export function unarchiveConversation(id: string): boolean {
   const now = Date.now();
   rawRun(
     "conversation:unarchive",
-    "UPDATE conversations SET archived_at = NULL, updated_at = ? WHERE id = ?",
+    "UPDATE conversations SET last_reopened_at = CASE WHEN archived_at IS NOT NULL THEN ? ELSE last_reopened_at END, archived_at = NULL, updated_at = ? WHERE id = ?",
+    now,
     now,
     id,
   );

package/src/persistence/conversation-queries.ts

@@ -137,6 +137,19 @@ function archiveStatusClause(status: ArchiveStatusFilter) {
   }
 }
 
+/**
+ * A conversation's last activity, the key every list read is ordered on: its
+ * latest message (its last update, for a row with no messages yet) or the
+ * moment it was marked done, whichever is later. Marking a chat done is
+ * something the user did to it, so a done chat files under the day it was
+ * marked done rather than the day it was last written to. An active row has
+ * no `archived_at`, so for every active listing this is plain message recency.
+ *
+ * SQLite's multi-argument `MAX` is NULL when any argument is, hence the
+ * `COALESCE` on each side.
+ */
+const lastActivitySql = sql`MAX(COALESCE(${conversations.lastMessageAt}, ${conversations.updatedAt}), COALESCE(${conversations.archivedAt}, 0))`;
+
 /**
  * Raw SQL predicate for "visible in the standard (Recents) listing".
  *
@@ -532,9 +545,7 @@ export function listConversations(
   ensureGroupMigration();
   const db = getDb();
   const { limit, offset = 0, ...filter } = query;
-  const recency = desc(
-    sql`COALESCE(${conversations.lastMessageAt}, ${conversations.updatedAt})`,
-  );
+  const recency = desc(lastActivitySql);
   // `id` closes the ordering so the sort is a total order. Rows tied on every
   // preceding key would otherwise have no defined relative order, which
   // becomes duplicated and skipped rows once a cursor pages across a tie
@@ -654,11 +665,7 @@ export function listPinnedConversations(
         ...(archiveCond ? [archiveCond] : []),
       ),
     )
-    .orderBy(
-      desc(
-        sql`COALESCE(${conversations.lastMessageAt}, ${conversations.updatedAt})`,
-      ),
-    );
+    .orderBy(desc(lastActivitySql));
   return query.all().map(parseConversation);
 }
 

package/src/persistence/embeddings/embed.test.ts

@@ -0,0 +1,96 @@
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+
+import { GeminiEmbedError } from "./embedding-gemini.js";
+
+// Capture delays passed to abortableSleep so tests can assert retry behavior
+// without depending on real clock.
+const sleepCalls: number[] = [];
+
+mock.module("../../util/retry.js", () => ({
+  abortableSleep: async (ms: number) => {
+    sleepCalls.push(ms);
+  },
+  computeRetryDelay: (attempt: number, base: number) =>
+    base * Math.pow(2, attempt),
+  isRetryableNetworkError: () => false,
+}));
+
+const mockEmbedWithBackend = mock();
+mock.module("./embedding-backend.js", () => ({
+  embedWithBackend: mockEmbedWithBackend,
+}));
+
+import { EMBED_BASE_DELAY_MS, embedWithRetry } from "./embed.js";
+
+const STUB_CONFIG = {} as Parameters<typeof embedWithRetry>[0];
+
+describe("embedWithRetry: Retry-After header", () => {
+  beforeEach(() => {
+    sleepCalls.length = 0;
+    mockEmbedWithBackend.mockClear();
+  });
+
+  afterEach(() => {
+    mockEmbedWithBackend.mockRestore();
+  });
+
+  test("uses retryAfterMs from error as the sleep delay when present", async () => {
+    const retryAfterMs = 5000;
+    mockEmbedWithBackend
+      .mockRejectedValueOnce(
+        new GeminiEmbedError("rate limited", 429, retryAfterMs),
+      )
+      .mockResolvedValueOnce({
+        provider: "gemini",
+        model: "m",
+        vectors: [[0.1, 0.2]],
+      });
+
+    await embedWithRetry(STUB_CONFIG, ["hello"]);
+
+    expect(sleepCalls).toHaveLength(1);
+    expect(sleepCalls[0]).toBe(retryAfterMs);
+  });
+
+  test("falls back to exponential backoff when retryAfterMs is absent", async () => {
+    mockEmbedWithBackend
+      .mockRejectedValueOnce(new GeminiEmbedError("rate limited", 429))
+      .mockResolvedValueOnce({
+        provider: "gemini",
+        model: "m",
+        vectors: [[0.1, 0.2]],
+      });
+
+    await embedWithRetry(STUB_CONFIG, ["hello"]);
+
+    expect(sleepCalls).toHaveLength(1);
+    expect(sleepCalls[0]).toBe(EMBED_BASE_DELAY_MS);
+  });
+
+  test("retries up to EMBED_MAX_RETRIES times before throwing", async () => {
+    const error = new GeminiEmbedError("rate limited", 429, 1);
+    mockEmbedWithBackend.mockRejectedValue(error);
+
+    await expect(embedWithRetry(STUB_CONFIG, ["hello"])).rejects.toThrow(
+      "rate limited",
+    );
+    expect(sleepCalls).toHaveLength(3);
+  });
+
+  test("returns result without retrying on success", async () => {
+    mockEmbedWithBackend.mockResolvedValueOnce({
+      provider: "gemini",
+      model: "m",
+      vectors: [[0.5, 0.6]],
+    });
+
+    const result = await embedWithRetry(STUB_CONFIG, ["hello"]);
+
+    expect(result).toEqual({
+      provider: "gemini",
+      model: "m",
+      vectors: [[0.5, 0.6]],
+    });
+    expect(sleepCalls).toHaveLength(0);
+  });
+});

package/src/persistence/embeddings/embed.ts

@@ -38,9 +38,16 @@ export async function embedWithRetry(
       if (!isTransient || attempt === EMBED_MAX_RETRIES) {
         throw err;
       }
-      const delay = computeRetryDelay(attempt, EMBED_BASE_DELAY_MS);
+      const retryAfterMs = getErrorRetryAfterMs(err);
+      const delay =
+        retryAfterMs ?? computeRetryDelay(attempt, EMBED_BASE_DELAY_MS);
       log.warn(
-        { err, attempt: attempt + 1, delayMs: Math.round(delay) },
+        {
+          err,
+          attempt: attempt + 1,
+          delayMs: Math.round(delay),
+          retryAfterHeader: retryAfterMs !== undefined,
+        },
         "Transient embedding failure, retrying",
       );
       await abortableSleep(delay, opts?.signal);
@@ -87,6 +94,17 @@ function getErrorStatusCode(err: Error): unknown {
   return undefined;
 }
 
+function getErrorRetryAfterMs(err: unknown): number | undefined {
+  if (!(err instanceof Error)) {
+    return undefined;
+  }
+  const candidate = (err as { retryAfterMs?: unknown }).retryAfterMs;
+  if (typeof candidate === "number" && candidate >= 0) {
+    return candidate;
+  }
+  return undefined;
+}
+
 function isHttpStatusError(err: unknown): boolean {
   if (!(err instanceof Error)) {
     return false;

package/src/persistence/embeddings/embedding-gemini.test.ts

@@ -1,6 +1,9 @@
 import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
 
-import { GeminiEmbeddingBackend } from "./embedding-gemini.js";
+import {
+  GeminiEmbeddingBackend,
+  GeminiEmbedError,
+} from "./embedding-gemini.js";
 
 function makeSuccessResponse(values: number[]) {
   return new Response(JSON.stringify({ embedding: { values } }), {
@@ -186,18 +189,51 @@ describe("GeminiEmbeddingBackend", () => {
   });
 
   describe("error handling", () => {
-    test("throws on non-OK response", async () => {
+    test("throws GeminiEmbedError on non-OK response", async () => {
       mockFetch = mock(() =>
         Promise.resolve(new Response("Internal Server Error", { status: 500 })),
       );
       globalThis.fetch = mockFetch as unknown as typeof fetch;
 
       const backend = new GeminiEmbeddingBackend("test-key", "test-model");
-      await expect(backend.embed(["hello"])).rejects.toThrow(
+      const err = await backend.embed(["hello"]).catch((e: unknown) => e);
+      expect(err).toBeInstanceOf(GeminiEmbedError);
+      expect((err as GeminiEmbedError).status).toBe(500);
+      expect((err as GeminiEmbedError).message).toContain(
         "Gemini embeddings request failed (500): Internal Server Error",
       );
     });
 
+    test("attaches retryAfterMs from Retry-After delta-seconds header on 429", async () => {
+      mockFetch = mock(() =>
+        Promise.resolve(
+          new Response("rate limited", {
+            status: 429,
+            headers: { "Retry-After": "30" },
+          }),
+        ),
+      );
+      globalThis.fetch = mockFetch as unknown as typeof fetch;
+
+      const backend = new GeminiEmbeddingBackend("test-key", "test-model");
+      const err = await backend.embed(["hello"]).catch((e: unknown) => e);
+      expect(err).toBeInstanceOf(GeminiEmbedError);
+      expect((err as GeminiEmbedError).status).toBe(429);
+      expect((err as GeminiEmbedError).retryAfterMs).toBe(30000);
+    });
+
+    test("retryAfterMs is undefined on 429 without Retry-After header", async () => {
+      mockFetch = mock(() =>
+        Promise.resolve(new Response("rate limited", { status: 429 })),
+      );
+      globalThis.fetch = mockFetch as unknown as typeof fetch;
+
+      const backend = new GeminiEmbeddingBackend("test-key", "test-model");
+      const err = await backend.embed(["hello"]).catch((e: unknown) => e);
+      expect(err).toBeInstanceOf(GeminiEmbedError);
+      expect((err as GeminiEmbedError).retryAfterMs).toBeUndefined();
+    });
+
     test("throws when response is missing embedding values", async () => {
       mockFetch = mock(() =>
         Promise.resolve(

package/src/persistence/embeddings/embedding-gemini.ts

@@ -10,6 +10,17 @@ import { normalizeEmbeddingInput } from "./embedding-types.js";
 
 const log = getLogger("memory-embeddings");
 
+export class GeminiEmbedError extends Error {
+  readonly status: number;
+  readonly retryAfterMs?: number;
+  constructor(message: string, status: number, retryAfterMs?: number) {
+    super(message);
+    this.name = "GeminiEmbedError";
+    this.status = status;
+    this.retryAfterMs = retryAfterMs;
+  }
+}
+
 interface GeminiEmbedResponse {
   embedding?: {
     values?: number[];
@@ -277,8 +288,13 @@ export class GeminiEmbeddingBackend implements EmbeddingBackend {
     });
     if (!response.ok) {
       const responseBody = await response.text();
-      throw new Error(
+      const retryAfterMs = parseRetryAfterHeader(
+        response.headers.get("Retry-After"),
+      );
+      throw new GeminiEmbedError(
         `Gemini embeddings request failed (${response.status}): ${responseBody}`,
+        response.status,
+        retryAfterMs,
       );
     }
     const payload = (await response.json()) as GeminiEmbedResponse;
@@ -322,3 +338,25 @@ export class GeminiEmbeddingBackend implements EmbeddingBackend {
     ];
   }
 }
+
+/**
+ * Parse the value of a `Retry-After` response header into milliseconds.
+ * Accepts a delta-seconds integer ("30") or an HTTP date string.
+ * Returns undefined when the value is absent, unparseable, or in the past.
+ */
+function parseRetryAfterHeader(value: string | null): number | undefined {
+  if (!value) {
+    return undefined;
+  }
+  const trimmed = value.trim();
+  const seconds = Number(trimmed);
+  if (!Number.isNaN(seconds) && seconds >= 0) {
+    return Math.ceil(seconds * 1000);
+  }
+  const date = new Date(trimmed);
+  if (!isNaN(date.getTime())) {
+    const ms = date.getTime() - Date.now();
+    return ms > 0 ? ms : undefined;
+  }
+  return undefined;
+}

package/src/persistence/embeddings/embedding-local.ts

@@ -11,6 +11,10 @@ import type { Subprocess } from "bun";
 
 import { getIsContainerized } from "../../config/env-registry.js";
 import { getLogger } from "../../util/logger.js";
+import {
+  setOomScoreAdj,
+  WORKER_OOM_SCORE_ADJ,
+} from "../../util/oom-priority.js";
 import {
   getEmbeddingModelsDir,
   getEmbedWorkerPidPath,
@@ -395,6 +399,8 @@ export class LocalEmbeddingBackend implements EmbeddingBackend {
       cwd: embeddingModelsDir,
     });
 
+    setOomScoreAdj(WORKER_OOM_SCORE_ADJ, proc.pid);
+
     // Type-compatible assignment
     this.workerProc = proc;
 

package/src/persistence/embeddings/qdrant-manager.ts

@@ -17,6 +17,10 @@ import type { Subprocess } from "bun";
 
 import { getQdrantReadyzTimeoutMs, getQdrantUrlEnv } from "../../config/env.js";
 import { getLogger } from "../../util/logger.js";
+import {
+  setOomScoreAdj,
+  WORKER_OOM_SCORE_ADJ,
+} from "../../util/oom-priority.js";
 import { getDataDir } from "../../util/platform.js";
 
 const log = getLogger("qdrant-manager");
@@ -288,6 +292,7 @@ export class QdrantManager {
     } catch (err) {
       throw this.startError(err, "spawn");
     }
+    setOomScoreAdj(WORKER_OOM_SCORE_ADJ, proc.pid);
     this.process = proc;
     this.drainOutputFrom(proc.stdout, proc.stderr);
 

package/src/persistence/job-utils.ts

@@ -54,6 +54,16 @@ export const RETRY_MAX_ATTEMPTS = 8;
  * Fatal: 400 bad request, 401 auth, 403 permission, other 4xx client errors.
  */
 export function classifyError(err: unknown): ErrorCategory {
+  // LOCAL PATCH (juno, 2026-09-26): SQLite write contention is transient, retry it.
+  if (
+    err instanceof Error &&
+    (/database is locked|SQLITE_BUSY/i.test(err.message) ||
+      /^SQLITE_(BUSY|IOERR)/.test(
+        String((err as Error & { code?: string }).code ?? ""),
+      ))
+  ) {
+    return "retryable";
+  }
   // Timeout errors from our own Promise.race wrappers
   if (err instanceof Error && err.message.includes("timeout")) {
     return "retryable";

package/src/persistence/migrations/384-add-document-revision.test.ts

@@ -0,0 +1,83 @@
+import { Database } from "bun:sqlite";
+import { describe, expect, test } from "bun:test";
+
+import { drizzle } from "drizzle-orm/bun-sqlite";
+
+import * as schema from "../schema.js";
+import { migrateAddDocumentWorkspacePath } from "./360-add-document-workspace-path.js";
+import { migrateAddDocumentRevision } from "./384-add-document-revision.js";
+
+/** Pre-384 shape: the documents table as core tables and migration 360 left it. */
+function createTestDb() {
+  const sqlite = new Database(":memory:");
+  sqlite.exec(/*sql*/ `
+    CREATE TABLE conversations (
+      id TEXT PRIMARY KEY,
+      created_at INTEGER NOT NULL
+    );
+
+    CREATE TABLE documents (
+      surface_id TEXT PRIMARY KEY,
+      conversation_id TEXT NOT NULL REFERENCES conversations(id) ON DELETE CASCADE,
+      title TEXT NOT NULL,
+      content TEXT NOT NULL,
+      word_count INTEGER NOT NULL DEFAULT 0,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL
+    );
+
+    INSERT INTO conversations (id, created_at) VALUES ('conv-1', 1000);
+    INSERT INTO documents (surface_id, conversation_id, title, content, word_count, created_at, updated_at)
+      VALUES ('doc-1', 'conv-1', 'Doc', 'body', 1, 1000, 1000);
+  `);
+  const db = drizzle(sqlite, { schema });
+  migrateAddDocumentWorkspacePath(db);
+  return { sqlite, db };
+}
+
+function revisionColumn(sqlite: Database) {
+  return (
+    sqlite.query("PRAGMA table_info(documents)").all() as Array<{
+      name: string;
+      notnull: number;
+      dflt_value: string | null;
+    }>
+  ).find((c) => c.name === "revision");
+}
+
+describe("migration 384: documents.revision", () => {
+  test("adds a NOT NULL column defaulting to 0", () => {
+    const { sqlite, db } = createTestDb();
+    expect(revisionColumn(sqlite)).toBeUndefined();
+
+    migrateAddDocumentRevision(db);
+
+    const column = revisionColumn(sqlite);
+    expect(column?.notnull).toBe(1);
+    expect(column?.dflt_value).toBe("0");
+  });
+
+  test("existing rows read revision 0", () => {
+    const { sqlite, db } = createTestDb();
+
+    migrateAddDocumentRevision(db);
+
+    const row = sqlite
+      .query("SELECT revision FROM documents WHERE surface_id = 'doc-1'")
+      .get() as { revision: number };
+    expect(row.revision).toBe(0);
+  });
+
+  test("is idempotent", () => {
+    const { sqlite, db } = createTestDb();
+
+    migrateAddDocumentRevision(db);
+    sqlite.run("UPDATE documents SET revision = 3 WHERE surface_id = 'doc-1'");
+    expect(() => migrateAddDocumentRevision(db)).not.toThrow();
+
+    const row = sqlite
+      .query("SELECT revision FROM documents WHERE surface_id = 'doc-1'")
+      .get() as { revision: number };
+    expect(row.revision).toBe(3);
+  });
+});

package/src/persistence/migrations/384-add-document-revision.ts

@@ -0,0 +1,21 @@
+import type { DrizzleDb } from "../db-connection.js";
+import { tableHasColumn } from "./schema-introspection.js";
+
+const COLUMN_NAME = "revision";
+const COLUMN_DEFINITION = "revision INTEGER NOT NULL DEFAULT 0";
+
+/**
+ * Add `revision` to `documents`: a counter every write bumps by one, which
+ * lets a client make its save conditional on the revision it last saw.
+ *
+ * Existing rows start at 0 with no backfill; their next write moves them to 1.
+ *
+ * Idempotent: guarded with `tableHasColumn` so a crash between the `ALTER
+ * TABLE` and the checkpoint write does not raise a duplicate-column error on
+ * the next boot.
+ */
+export function migrateAddDocumentRevision(database: DrizzleDb): void {
+  if (!tableHasColumn(database, "documents", COLUMN_NAME)) {
+    database.run(`ALTER TABLE documents ADD COLUMN ${COLUMN_DEFINITION}`);
+  }
+}