@vellumai/assistant 0.5.6 → 0.5.8

package/src/__tests__/keychain-broker-client.test.ts

@@ -537,8 +537,8 @@ describe("keychain-broker-client", () => {
       writeFileSync(SOCKET_PATH, "");
       expect(client.isAvailable()).toBe(false);
 
-      // Advance time past the first cooldown (30s)
-      fakeNow += 30_001;
+      // Advance time past the first cooldown (5s)
+      fakeNow += 5_001;
       expect(client.isAvailable()).toBe(true);
 
       // Now start a real broker and verify the client reconnects
@@ -558,8 +558,8 @@ describe("keychain-broker-client", () => {
       const client = createBrokerClient();
       await client.ping();
 
-      // Advance past first cooldown (30s)
-      fakeNow += 30_001;
+      // Advance past first cooldown (5s)
+      fakeNow += 5_001;
 
       // Start broker — reconnection should succeed and reset counters
       const broker = createMockBroker();
@@ -578,15 +578,15 @@ describe("keychain-broker-client", () => {
       rmSync(SOCKET_PATH, { force: true });
 
       // This new failure should start from the beginning of the cooldown
-      // schedule (30s), not escalated.
+      // schedule (5s), not escalated.
       await client.ping();
 
-      // Verify cooldown is back to 30s (not 60s)
+      // Verify cooldown is back to 5s (not 15s)
       writeFileSync(SOCKET_PATH, "");
       expect(client.isAvailable()).toBe(false);
 
-      // 30s should be enough to clear cooldown
-      fakeNow += 30_001;
+      // 5s should be enough to clear cooldown
+      fakeNow += 5_001;
       expect(client.isAvailable()).toBe(true);
     }, 15_000);
 
@@ -594,60 +594,73 @@ describe("keychain-broker-client", () => {
       const client = createBrokerClient();
 
       // First failure round: two attempts (first + immediate retry) ->
-      // consecutiveFailures=2, cooldown index = max(2-2,0) = 0 -> 30s.
+      // consecutiveFailures=2, cooldown index = max(2-2,0) = 0 -> 5s.
       await client.ping();
 
       writeFileSync(SOCKET_PATH, "");
       expect(client.isAvailable()).toBe(false);
 
-      // 30s should clear the first cooldown
-      fakeNow += 30_001;
+      // 5s should clear the first cooldown
+      fakeNow += 5_001;
       expect(client.isAvailable()).toBe(true);
 
       // Remove socket to trigger another failure. After cooldown elapses,
       // ensureConnected clears unavailableSince and tries connect().
       // This failure increments consecutiveFailures to 3 (no immediate retry
       // since consecutiveFailures > 1 after increment).
-      // Cooldown index = max(3-2,0) = 1 -> 60s.
+      // Cooldown index = max(3-2,0) = 1 -> 15s.
       rmSync(SOCKET_PATH, { force: true });
       await client.ping();
 
       writeFileSync(SOCKET_PATH, "");
       expect(client.isAvailable()).toBe(false);
 
-      fakeNow += 30_001;
-      expect(client.isAvailable()).toBe(false); // 30s not enough
+      fakeNow += 5_001;
+      expect(client.isAvailable()).toBe(false); // 5s not enough
 
-      fakeNow += 30_000; // total 60_001ms since this cooldown started
+      fakeNow += 10_000; // total 15_001ms since this cooldown started
       expect(client.isAvailable()).toBe(true);
 
-      // Another failure -> consecutiveFailures=4, index = max(4-2,0) = 2 -> 120s (2min)
+      // Another failure -> consecutiveFailures=4, index = max(4-2,0) = 2 -> 30s
       rmSync(SOCKET_PATH, { force: true });
       await client.ping();
 
       writeFileSync(SOCKET_PATH, "");
       expect(client.isAvailable()).toBe(false);
 
-      fakeNow += 60_001;
+      fakeNow += 15_001;
+      expect(client.isAvailable()).toBe(false);
+
+      fakeNow += 15_000; // total 30_001ms
+      expect(client.isAvailable()).toBe(true);
+
+      // Another failure -> consecutiveFailures=5, index = max(5-2,0) = 3 -> 60s
+      rmSync(SOCKET_PATH, { force: true });
+      await client.ping();
+
+      writeFileSync(SOCKET_PATH, "");
+      expect(client.isAvailable()).toBe(false);
+
+      fakeNow += 30_001;
       expect(client.isAvailable()).toBe(false);
 
-      fakeNow += 60_000; // total 120_001ms
+      fakeNow += 30_000; // total 60_001ms
       expect(client.isAvailable()).toBe(true);
 
-      // Another failure -> consecutiveFailures=5, index = max(5-2,0) = 3 -> 300s (5min)
+      // Another failure -> consecutiveFailures=6, index = min(max(6-2,0), 4) = 4 -> 300s (5min)
       rmSync(SOCKET_PATH, { force: true });
       await client.ping();
 
       writeFileSync(SOCKET_PATH, "");
       expect(client.isAvailable()).toBe(false);
 
-      fakeNow += 120_001;
+      fakeNow += 60_001;
       expect(client.isAvailable()).toBe(false);
 
-      fakeNow += 180_000; // total 300_001ms
+      fakeNow += 240_000; // total 300_001ms
       expect(client.isAvailable()).toBe(true);
 
-      // Another failure -> consecutiveFailures=6, index = min(max(6-2,0), 3) = 3 -> 300s (capped)
+      // Another failure -> consecutiveFailures=7, index = min(max(7-2,0), 4) = 4 -> 300s (capped)
       rmSync(SOCKET_PATH, { force: true });
       await client.ping();
 
@@ -658,4 +671,130 @@ describe("keychain-broker-client", () => {
       expect(client.isAvailable()).toBe(true);
     });
   });
+
+  // -----------------------------------------------------------------------
+  // Connect timeout
+  // -----------------------------------------------------------------------
+  describe("connect timeout", () => {
+    let stopFn: (() => Promise<void>) | null = null;
+
+    beforeEach(() => {
+      writeFileSync(TOKEN_PATH, TEST_TOKEN);
+    });
+
+    afterEach(async () => {
+      if (stopFn) {
+        await stopFn();
+        stopFn = null;
+      }
+    });
+
+    test("rejects connect within 3 seconds when broker is unresponsive", async () => {
+      // Create a server that accepts connections but never responds
+      // (simulates an unresponsive broker process).
+      const activeConns = new Set<import("node:net").Socket>();
+      const server = createServer((conn) => {
+        activeConns.add(conn);
+        conn.on("close", () => activeConns.delete(conn));
+        // Accept connection but do nothing — no data, no close
+      });
+      await new Promise<void>((resolve) => {
+        server.listen(SOCKET_PATH, () => resolve());
+      });
+      stopFn = () =>
+        new Promise<void>((resolve) => {
+          for (const conn of activeConns) conn.destroy();
+          activeConns.clear();
+          server.close(() => resolve());
+        });
+
+      const client = createBrokerClient();
+      const start = Date.now();
+      const result = await client.ping();
+      const elapsed = Date.now() - start;
+
+      // Should return null (graceful fallback) and not hang indefinitely.
+      // The connect timeout is 3s; allow some slack but it should be well
+      // under 10s (the old behavior would hang for REQUEST_TIMEOUT_MS * retries).
+      expect(result).toBeNull();
+      expect(elapsed).toBeLessThan(10_000);
+    }, 15_000);
+
+    test("successful connect clears the connect timer", async () => {
+      // Normal broker that responds to pings — verifies the timer is cleared
+      // and doesn't fire after a successful connection.
+      const broker = createMockBroker();
+      broker.setHandler(() => ({ ok: true, result: { pong: true } }));
+      await broker.start();
+      stopFn = () => broker.stop();
+
+      const client = createBrokerClient();
+      const result = await client.ping();
+      expect(result).toEqual({ pong: true });
+
+      // Wait a bit past the connect timeout to ensure no stale timer fires
+      await new Promise((r) => setTimeout(r, 100));
+
+      // Client should still work fine
+      const result2 = await client.ping();
+      expect(result2).toEqual({ pong: true });
+    });
+  });
+
+  // -----------------------------------------------------------------------
+  // Reduced initial cooldown
+  // -----------------------------------------------------------------------
+  describe("reduced initial cooldown", () => {
+    const originalDateNow = Date.now;
+    let fakeNow: number;
+
+    beforeEach(() => {
+      fakeNow = originalDateNow.call(Date);
+      Date.now = () => fakeNow;
+      writeFileSync(TOKEN_PATH, TEST_TOKEN);
+    });
+
+    afterEach(() => {
+      Date.now = originalDateNow;
+    });
+
+    test("first cooldown is 5 seconds, not 30 seconds", async () => {
+      const client = createBrokerClient();
+
+      // Trigger two connection failures (first + immediate retry)
+      await client.ping();
+
+      writeFileSync(SOCKET_PATH, "");
+
+      // Should still be in cooldown at 4 seconds
+      fakeNow += 4_000;
+      expect(client.isAvailable()).toBe(false);
+
+      // Should be available after 5 seconds
+      fakeNow += 1_001;
+      expect(client.isAvailable()).toBe(true);
+    });
+
+    test("second cooldown is 15 seconds", async () => {
+      const client = createBrokerClient();
+
+      // First failure round -> cooldown 5s
+      await client.ping();
+
+      // Clear first cooldown
+      fakeNow += 5_001;
+
+      // Second failure -> cooldown 15s
+      await client.ping();
+
+      writeFileSync(SOCKET_PATH, "");
+      expect(client.isAvailable()).toBe(false);
+
+      fakeNow += 14_000;
+      expect(client.isAvailable()).toBe(false);
+
+      fakeNow += 1_001;
+      expect(client.isAvailable()).toBe(true);
+    });
+  });
 });

package/src/__tests__/memory-context-benchmark.benchmark.test.ts

@@ -5,7 +5,6 @@
  * - compaction.summaryCalls: 2-6
  * - compaction.estimatedInputTokens: < previousEstimatedInputTokens
  * - recall.injectedTokens: <= computed dynamic budget
- * - recall.recencyHits: > 0
  * - recall.enabled: true
  */
 import { mkdtempSync, rmSync } from "node:fs";
@@ -303,8 +302,6 @@ describe("Memory context benchmark", () => {
       { maxInjectTokensOverride: recallBudget },
     );
 
-    // Recency search finds conversation-scoped segments.
-    expect(recall.recencyHits).toBeGreaterThan(0);
     expect(recall.enabled).toBe(true);
     // With Qdrant mock returning a high-scoring result, content should be injected.
     expect(recall.selectedCount).toBeGreaterThan(0);

package/src/__tests__/memory-jobs-worker-backoff.test.ts

@@ -0,0 +1,150 @@
+/**
+ * Tests for adaptive poll interval backoff in the memory jobs worker.
+ *
+ * Verifies that when no jobs are claimable, the poll interval doubles each
+ * tick (1.5s -> 3s -> 6s -> ... -> 30s cap), and resets to 1.5s when work
+ * is found.
+ */
+import { describe, expect, mock, test } from "bun:test";
+
+// ── Mocks (must precede imports of tested module) ──────────────────
+
+mock.module("../util/platform.js", () => ({
+  getDataDir: () => "/tmp/test-backoff",
+  isMacOS: () => false,
+  isLinux: () => true,
+  isWindows: () => false,
+  getPidPath: () => "/tmp/test-backoff/test.pid",
+  getDbPath: () => "/tmp/test-backoff/test.db",
+  getLogPath: () => "/tmp/test-backoff/test.log",
+  ensureDataDir: () => {},
+}));
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+// Mock config — memory disabled so runMemoryJobsOnce returns 0 immediately
+mock.module("../config/loader.js", () => ({
+  getConfig: () => ({
+    memory: { enabled: false },
+  }),
+  loadConfig: () => ({
+    memory: { enabled: false },
+  }),
+}));
+
+// Mock jobs-store (accesses DB)
+mock.module("../memory/jobs-store.js", () => ({
+  resetRunningJobsToPending: () => 0,
+  claimMemoryJobs: () => [],
+  completeMemoryJob: () => {},
+  deferMemoryJob: () => "deferred",
+  failMemoryJob: () => {},
+  failStalledJobs: () => 0,
+  enqueueCleanupStaleSupersededItemsJob: () => null,
+  enqueuePruneOldConversationsJob: () => null,
+}));
+
+// Mock db.js (rawRun used in sweepStaleItems)
+mock.module("../memory/db.js", () => ({
+  rawRun: () => 0,
+}));
+
+import {
+  POLL_INTERVAL_MAX_MS,
+  POLL_INTERVAL_MIN_MS,
+  startMemoryJobsWorker,
+} from "../memory/jobs-worker.js";
+
+describe("memory jobs worker adaptive poll interval", () => {
+  test("exports expected poll interval constants", () => {
+    expect(POLL_INTERVAL_MIN_MS).toBe(1_500);
+    expect(POLL_INTERVAL_MAX_MS).toBe(30_000);
+  });
+
+  test("backoff sequence doubles from min to max then caps", () => {
+    // Verify the math: starting at 1500, doubling each step, capped at 30000
+    const intervals: number[] = [];
+    let current = POLL_INTERVAL_MIN_MS;
+    for (let i = 0; i < 10; i++) {
+      intervals.push(current);
+      current = Math.min(current * 2, POLL_INTERVAL_MAX_MS);
+    }
+    expect(intervals).toEqual([
+      1_500, // tick 1
+      3_000, // tick 2
+      6_000, // tick 3
+      12_000, // tick 4
+      24_000, // tick 5
+      30_000, // tick 6 (capped)
+      30_000, // stays capped
+      30_000,
+      30_000,
+      30_000,
+    ]);
+  });
+
+  test("worker schedules setTimeout with increasing intervals when idle", async () => {
+    const timeoutDelays: number[] = [];
+    const originalSetTimeout = globalThis.setTimeout;
+    const originalClearTimeout = globalThis.clearTimeout;
+
+    // Collect pending timer callbacks so we can fire them manually
+    const pendingCallbacks: Array<() => void> = [];
+
+    globalThis.setTimeout = ((fn: () => void, delay?: number) => {
+      if (delay !== undefined && delay >= POLL_INTERVAL_MIN_MS) {
+        timeoutDelays.push(delay);
+        pendingCallbacks.push(fn);
+      }
+      return 999 as unknown as ReturnType<typeof setTimeout>;
+    }) as typeof setTimeout;
+    globalThis.clearTimeout = (() => {}) as typeof clearTimeout;
+
+    try {
+      const worker = startMemoryJobsWorker();
+
+      // Wait for the initial tick() promise to settle
+      await new Promise((resolve) => originalSetTimeout(resolve, 20));
+
+      // Fire pending timer callbacks to advance through the backoff sequence.
+      // Each callback triggers tick() which is async, so we await a microtask
+      // after each to let the promise chain settle and schedule the next timer.
+      for (let i = 0; i < 6; i++) {
+        const cb = pendingCallbacks.shift();
+        if (cb) {
+          cb();
+          await new Promise((resolve) => originalSetTimeout(resolve, 20));
+        }
+      }
+
+      worker.stop();
+
+      // We should have captured several setTimeout calls with increasing delays
+      expect(timeoutDelays.length).toBeGreaterThanOrEqual(4);
+
+      // Intervals should be non-decreasing (backoff)
+      for (let i = 1; i < timeoutDelays.length; i++) {
+        expect(timeoutDelays[i]).toBeGreaterThanOrEqual(timeoutDelays[i - 1]!);
+      }
+
+      // All intervals within bounds
+      for (const delay of timeoutDelays) {
+        expect(delay).toBeGreaterThanOrEqual(POLL_INTERVAL_MIN_MS);
+        expect(delay).toBeLessThanOrEqual(POLL_INTERVAL_MAX_MS);
+      }
+
+      // Should eventually reach the cap
+      expect(timeoutDelays[timeoutDelays.length - 1]).toBe(
+        POLL_INTERVAL_MAX_MS,
+      );
+    } finally {
+      globalThis.setTimeout = originalSetTimeout;
+      globalThis.clearTimeout = originalClearTimeout;
+    }
+  });
+});

package/src/__tests__/memory-lifecycle-e2e.test.ts

@@ -2,7 +2,7 @@
  * Memory lifecycle E2E regression test.
  *
  * Verifies the new memory pipeline end-to-end:
- * - 6-kind enum items (identity, preference, project, decision, constraint, event)
+ * - Standard-kind enum items (identity, preference, project, decision, constraint, event, journal, capability, ...)
  * - Supersession chains (supersedes/supersededBy fields)
  * - Hybrid search retrieval
  * - Two-layer XML injection format (<memory_context> with sections)
@@ -44,10 +44,31 @@ mock.module("../util/logger.js", () => ({
     }),
 }));
 
+// Stub the local embedding backend so the real ONNX model never loads
+mock.module("../memory/embedding-local.js", () => ({
+  LocalEmbeddingBackend: class {
+    readonly provider = "local" as const;
+    readonly model: string;
+    constructor(model: string) {
+      this.model = model;
+    }
+    async embed(texts: string[]): Promise<number[][]> {
+      return texts.map(() => new Array(384).fill(0));
+    }
+  },
+}));
+
+// Dynamic Qdrant mock: tests can push results to be returned by searchWithFilter/hybridSearch
+let mockQdrantResults: Array<{
+  id: string;
+  score: number;
+  payload: Record<string, unknown>;
+}> = [];
+
 mock.module("../memory/qdrant-client.js", () => ({
   getQdrantClient: () => ({
-    searchWithFilter: async () => [],
-    hybridSearch: async () => [],
+    searchWithFilter: async () => mockQdrantResults,
+    hybridSearch: async () => mockQdrantResults,
     upsertPoints: async () => {},
     deletePoints: async () => {},
   }),
@@ -60,7 +81,6 @@ const TEST_CONFIG = {
     ...DEFAULT_CONFIG.memory,
     embeddings: {
       ...DEFAULT_CONFIG.memory.embeddings,
-      provider: "openai" as const,
       required: false,
     },
     extraction: {
@@ -115,6 +135,7 @@ describe("Memory lifecycle E2E regression", () => {
     db.run("DELETE FROM conversations");
     db.run("DELETE FROM memory_jobs");
     db.run("DELETE FROM memory_checkpoints");
+    mockQdrantResults = [];
     resetCleanupScheduleThrottle();
     resetStaleSweepThrottle();
   });
@@ -128,7 +149,7 @@ describe("Memory lifecycle E2E regression", () => {
     }
   });
 
-  test("extraction produces items with 6-kind enum and supersession chains form correctly", async () => {
+  test("extraction produces items with standard-kind enum and supersession chains form correctly", async () => {
     const db = getDb();
     const now = 1_701_100_000_000;
     const conversationId = "conv-memory-lifecycle";
@@ -165,7 +186,7 @@ describe("Memory lifecycle E2E regression", () => {
       ])
       .run();
 
-    // Seed items using the 6-kind enum
+    // Seed items using the standard-kind enum
     const kinds = [
       "identity",
       "preference",
@@ -299,12 +320,8 @@ describe("Memory lifecycle E2E regression", () => {
       TEST_CONFIG,
     );
 
-    // Recency search finds segments but their finalScore (semantic*0.7 +
-    // recency*0.2 + confidence*0.1) is too low to pass tier classification
-    // (threshold > 0.6) because semantic=0 with Qdrant mocked empty.
-    // Verify recency search ran successfully.
-    expect(recall.recencyHits).toBeGreaterThan(0);
-    // Candidates exist but don't pass tier classification, so injectedText is empty
+    // Without semantic search (Qdrant mocked empty), no candidates pass
+    // tier classification (threshold > 0.6).
     expect(recall.enabled).toBe(true);
   });
 
@@ -343,15 +360,47 @@ describe("Memory lifecycle E2E regression", () => {
       })
       .run();
 
-    db.run(`
-      INSERT INTO memory_segments (
-        id, message_id, conversation_id, role, segment_index, text, token_estimate, scope_id, created_at, updated_at
-      ) VALUES (
-        'seg-injection-seed', 'msg-injection-seed', '${conversationId}', 'user', 0,
-        'My preferred timezone is America/Los_Angeles.', 10, 'default',
-        ${now + 10}, ${now + 10}
-      )
-    `);
+    // Seed a memory item so the semantic search path can find it
+    db.insert(memoryItems)
+      .values({
+        id: "item-timezone-pref",
+        kind: "preference",
+        subject: "timezone preference",
+        statement: "My preferred timezone is America/Los_Angeles.",
+        status: "active",
+        confidence: 0.9,
+        importance: 0.8,
+        fingerprint: "fp-item-timezone-pref",
+        firstSeenAt: now + 10,
+        lastSeenAt: now + 10,
+      })
+      .run();
+
+    db.insert(memoryItemSources)
+      .values({
+        memoryItemId: "item-timezone-pref",
+        messageId: "msg-injection-seed",
+        evidence: "timezone preference evidence",
+        createdAt: now + 10,
+      })
+      .run();
+
+    // Mock Qdrant to return the timezone preference item
+    mockQdrantResults = [
+      {
+        id: "emb-timezone-pref",
+        score: 0.92,
+        payload: {
+          target_type: "item",
+          target_id: "item-timezone-pref",
+          text: "My preferred timezone is America/Los_Angeles.",
+          kind: "preference",
+          status: "active",
+          created_at: now + 10,
+          last_seen_at: now + 10,
+        },
+      },
+    ];
 
     const recall = await buildMemoryRecall(
       "timezone",
@@ -359,10 +408,6 @@ describe("Memory lifecycle E2E regression", () => {
       TEST_CONFIG,
     );
 
-    // The recency-only promotion path (Step 6 in retriever) ensures the
-    // seeded segment reaches tier 2 and is injected even without semantic
-    // search. Verify structure of the two-layer XML format.
-    expect(recall.recencyHits).toBeGreaterThan(0);
     expect(recall.enabled).toBe(true);
     expect(recall.injectedText.length).toBeGreaterThan(0);
     expect(recall.injectedTokens).toBeGreaterThan(0);