@vellumai/assistant 0.4.49 → 0.4.50

package/src/__tests__/host-cu-proxy.test.ts

@@ -6,11 +6,17 @@ describe("HostCuProxy", () => {
   let proxy: InstanceType<typeof HostCuProxy>;
   let sentMessages: unknown[];
   let sendToClient: (msg: unknown) => void;
+  let resolvedRequestIds: string[];
 
   function setup(maxSteps?: number) {
     sentMessages = [];
+    resolvedRequestIds = [];
     sendToClient = (msg: unknown) => sentMessages.push(msg);
-    proxy = new HostCuProxy(sendToClient as never, maxSteps);
+    proxy = new HostCuProxy(
+      sendToClient as never,
+      (requestId: string) => resolvedRequestIds.push(requestId),
+      maxSteps,
+    );
   }
 
   afterEach(() => {
@@ -364,6 +370,60 @@ describe("HostCuProxy", () => {
       );
     });
 
+    test("does not emit spurious warning on first observation", async () => {
+      setup();
+
+      // First ever request — no previous AX tree exists
+      proxy.recordAction("computer_use_click", { element_id: 1 });
+      const p1 = proxy.request(
+        "computer_use_click",
+        { element_id: 1 },
+        "session-1",
+        1,
+      );
+      const sent1 = sentMessages[0] as Record<string, unknown>;
+      proxy.resolve(sent1.requestId as string, {
+        axTree: "Button [1]",
+        // No axDiff on first observation — this is normal, not unchanged
+      });
+      const result1 = await p1;
+      expect(result1.content).not.toContain("NO VISIBLE EFFECT");
+    });
+
+    test("skips unchanged warning after computer_use_wait", async () => {
+      setup();
+
+      // Establish previous AX tree
+      const p1 = proxy.request(
+        "computer_use_click",
+        { element_id: 1 },
+        "session-1",
+        1,
+      );
+      proxy.recordAction("computer_use_click", { element_id: 1 });
+      const sent1 = sentMessages[0] as Record<string, unknown>;
+      proxy.resolve(sent1.requestId as string, {
+        axTree: "Button [1]",
+      });
+      await p1;
+
+      // Wait action with unchanged screen — should NOT warn
+      const p2 = proxy.request(
+        "computer_use_wait",
+        { duration_ms: 2000 },
+        "session-1",
+        2,
+      );
+      proxy.recordAction("computer_use_wait", { duration_ms: 2000 });
+      const sent2 = sentMessages[1] as Record<string, unknown>;
+      proxy.resolve(sent2.requestId as string, {
+        axTree: "Button [1]",
+        // No axDiff — screen unchanged, but that's expected after wait
+      });
+      const result2 = await p2;
+      expect(result2.content).not.toContain("NO VISIBLE EFFECT");
+    });
+
     test("resets consecutive count when diff is present", async () => {
       setup();
 
@@ -507,6 +567,35 @@ describe("HostCuProxy", () => {
       expect(result.content).toMatch(/<\/ax-tree>$/m);
     });
 
+    test("includes secondaryWindows after AX tree with cross-window note", () => {
+      setup();
+
+      const result = proxy.formatObservation({
+        axTree: "Button [1]\nLabel [2]",
+        secondaryWindows: "Safari — Window [10]\n  Link [11]",
+      });
+
+      expect(result.content).toContain("Safari — Window [10]");
+      expect(result.content).toContain("Link [11]");
+      expect(result.content).toContain(
+        "Note: The element [ID]s above are from other windows",
+      );
+      // secondaryWindows should appear after the AX tree
+      const axTreeEnd = result.content.indexOf("</ax-tree>");
+      const secondaryIdx = result.content.indexOf("Safari — Window [10]");
+      expect(axTreeEnd).toBeLessThan(secondaryIdx);
+    });
+
+    test("omits secondaryWindows section when field is absent", () => {
+      setup();
+
+      const result = proxy.formatObservation({
+        axTree: "Button [1]",
+      });
+
+      expect(result.content).not.toContain("other windows");
+    });
+
     test("includes diff when present", () => {
       setup();
 
@@ -576,7 +665,7 @@ describe("HostCuProxy", () => {
   // -------------------------------------------------------------------------
 
   describe("dispose", () => {
-    test("rejects all pending requests", () => {
+    test("rejects all pending requests", async () => {
       setup();
 
       const resultPromise = proxy.request(
@@ -593,7 +682,80 @@ describe("HostCuProxy", () => {
       proxy.dispose();
 
       expect(proxy.hasPendingRequest(requestId)).toBe(false);
-      expect(resultPromise).rejects.toThrow("Host CU proxy disposed");
+      await expect(resultPromise).rejects.toThrow("Host CU proxy disposed");
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // onInternalResolve callback
+  // -------------------------------------------------------------------------
+
+  describe("onInternalResolve", () => {
+    test("calls onInternalResolve when abort signal fires", async () => {
+      setup();
+
+      const controller = new AbortController();
+      const resultPromise = proxy.request(
+        "computer_use_click",
+        { element_id: 1 },
+        "session-1",
+        1,
+        undefined,
+        controller.signal,
+      );
+
+      const sent = sentMessages[0] as Record<string, unknown>;
+      const requestId = sent.requestId as string;
+
+      controller.abort();
+
+      await resultPromise;
+      expect(resolvedRequestIds).toContain(requestId);
+    });
+
+    test("calls onInternalResolve on dispose", async () => {
+      setup();
+
+      const resultPromise = proxy.request(
+        "computer_use_click",
+        { element_id: 1 },
+        "session-1",
+        1,
+      );
+
+      const sent = sentMessages[0] as Record<string, unknown>;
+      const requestId = sent.requestId as string;
+
+      proxy.dispose();
+
+      // dispose rejects pending requests — catch to avoid unhandled rejection
+      await resultPromise.catch(() => {});
+
+      expect(resolvedRequestIds).toContain(requestId);
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // isAvailable
+  // -------------------------------------------------------------------------
+
+  describe("isAvailable", () => {
+    test("returns false by default", () => {
+      setup();
+      expect(proxy.isAvailable()).toBe(false);
+    });
+
+    test("returns true after updateSender with clientConnected=true", () => {
+      setup();
+      proxy.updateSender(sendToClient as never, true);
+      expect(proxy.isAvailable()).toBe(true);
+    });
+
+    test("returns false after updateSender with clientConnected=false", () => {
+      setup();
+      proxy.updateSender(sendToClient as never, true);
+      proxy.updateSender(sendToClient as never, false);
+      expect(proxy.isAvailable()).toBe(false);
     });
   });
 

package/src/__tests__/http-user-message-parity.test.ts

@@ -170,6 +170,7 @@ function makeSession(overrides: Record<string, unknown> = {}) {
     setHostBashProxy: () => {},
     setHostFileProxy: () => {},
     setHostCuProxy: () => {},
+    addPreactivatedSkillId: () => {},
     emitConfirmationStateChanged: () => {},
     emitActivityState: () => {},
     setTurnChannelContext: () => {},

package/src/__tests__/invite-redemption-service.test.ts

@@ -23,7 +23,10 @@ mock.module("../util/logger.js", () => ({
     }),
 }));
 
-import { findContactChannel } from "../contacts/contact-store.js";
+import {
+  findContactChannel,
+  upsertContact,
+} from "../contacts/contact-store.js";
 import { upsertContactChannel } from "../contacts/contacts-write.js";
 import { getSqlite, initializeDb, resetDb } from "../memory/db.js";
 import {
@@ -278,6 +281,67 @@ describe("invite-redemption-service", () => {
     expect(outcome).toEqual({ ok: false, reason: "invalid_token" });
   });
 
+  test("returns invalid_token for a revoked guardian to prevent invite-based reactivation", () => {
+    const { rawToken } = createInvite({
+      sourceChannel: "telegram",
+      maxUses: 5,
+    });
+
+    // Pre-create a guardian contact with a revoked telegram channel
+    upsertContact({
+      displayName: "Guardian",
+      role: "guardian",
+      channels: [
+        {
+          type: "telegram",
+          address: "guardian-tg-id",
+          externalUserId: "guardian-tg-id",
+          status: "revoked",
+        },
+      ],
+    });
+
+    const outcome = redeemInvite({
+      rawToken,
+      sourceChannel: "telegram",
+      externalUserId: "guardian-tg-id",
+    });
+
+    // Must reject — guardian channels are managed via the binding flow, not invites
+    expect(outcome).toEqual({ ok: false, reason: "invalid_token" });
+  });
+
+  test("returns invalid_token for a revoked guardian via 6-digit invite code", () => {
+    const code = "123456";
+    const inviteCodeHash = hashVoiceCode(code);
+    createInvite({
+      sourceChannel: "telegram",
+      maxUses: 5,
+      inviteCodeHash,
+    });
+
+    upsertContact({
+      displayName: "Guardian",
+      role: "guardian",
+      channels: [
+        {
+          type: "telegram",
+          address: "guardian-code-id",
+          externalUserId: "guardian-code-id",
+          status: "revoked",
+        },
+      ],
+    });
+
+    const outcome = redeemInviteByCode({
+      code,
+      sourceChannel: "telegram",
+      externalUserId: "guardian-code-id",
+    });
+
+    expect(outcome).toEqual({ ok: false, reason: "invalid_token" });
+  });
+
   test("does not return already_member for a revoked member", () => {
     const { rawToken } = createInvite({
       sourceChannel: "telegram",

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

@@ -264,7 +264,7 @@ describe("keychain-broker-client", () => {
 
       const client = createBrokerClient();
       const result = await client.set("my-key", "new-value");
-      expect(result).toBe(true);
+      expect(result).toEqual({ status: "ok" });
     });
 
     test("del returns true on success", async () => {
@@ -434,11 +434,11 @@ describe("keychain-broker-client", () => {
       expect(result).toBeNull();
     });
 
-    test("set returns false when socket file does not exist", async () => {
+    test("set returns unreachable when socket file does not exist", async () => {
       writeFileSync(TOKEN_PATH, TEST_TOKEN);
       const client = createBrokerClient();
       const result = await client.set("test-key", "value");
-      expect(result).toBe(false);
+      expect(result).toEqual({ status: "unreachable" });
     });
 
     test("del returns false when socket file does not exist", async () => {
@@ -470,7 +470,7 @@ describe("keychain-broker-client", () => {
       }
       const client = createBrokerClient();
       expect(await client.get("key")).toBeNull();
-      expect(await client.set("key", "val")).toBe(false);
+      expect(await client.set("key", "val")).toEqual({ status: "unreachable" });
       expect(await client.del("key")).toBe(false);
       expect(await client.list()).toEqual([]);
       expect(await client.ping()).toBeNull();

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

@@ -5,8 +5,8 @@
  * - compaction.summaryCalls: 2-6
  * - compaction.estimatedInputTokens: < previousEstimatedInputTokens
  * - recall.injectedTokens: <= computed dynamic budget
- * - recall.lexicalHits: > 0
  * - recall.recencyHits: > 0
+ * - recall.enabled: true
  */
 import { mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
@@ -50,6 +50,37 @@ 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 so the benchmark can inject high-scoring results
+let mockQdrantResults: Array<{
+  id: string;
+  score: number;
+  payload: Record<string, unknown>;
+}> = [];
+
+mock.module("../memory/qdrant-client.js", () => ({
+  getQdrantClient: () => ({
+    searchWithFilter: async () => mockQdrantResults,
+    hybridSearch: async () => mockQdrantResults,
+    upsertPoints: async () => {},
+    deletePoints: async () => {},
+  }),
+  initQdrantClient: () => {},
+}));
+
 function makeLongMessages(turns: number): Message[] {
   const rows: Message[] = [];
   const userTail =
@@ -161,18 +192,15 @@ describe("Memory context benchmark", () => {
   beforeEach(() => {
     const db = getDb();
     db.run("DELETE FROM memory_item_sources");
-    db.run("DELETE FROM memory_item_entities");
-    db.run("DELETE FROM memory_entity_relations");
-    db.run("DELETE FROM memory_entities");
     db.run("DELETE FROM memory_embeddings");
-    db.run("DELETE FROM memory_summaries");
     db.run("DELETE FROM memory_items");
-    db.run("DELETE FROM memory_segment_fts");
+
     db.run("DELETE FROM memory_segments");
     db.run("DELETE FROM messages");
     db.run("DELETE FROM conversations");
     db.run("DELETE FROM memory_jobs");
     db.run("DELETE FROM memory_checkpoints");
+    mockQdrantResults = [];
   });
 
   afterAll(() => {
@@ -225,13 +253,7 @@ describe("Memory context benchmark", () => {
         },
         retrieval: {
           ...DEFAULT_CONFIG.memory.retrieval,
-          lexicalTopK: 50,
-          semanticTopK: 20,
           maxInjectTokens: 750,
-          reranking: {
-            ...DEFAULT_CONFIG.memory.retrieval.reranking,
-            enabled: false,
-          },
           dynamicBudget: {
             enabled: true,
             minInjectTokens: 160,
@@ -257,6 +279,23 @@ describe("Memory context benchmark", () => {
         recallConfig.memory.retrieval.dynamicBudget.maxInjectTokens,
     });
 
+    // Seed Qdrant mock with a representative decision segment so
+    // the benchmark validates content quality, not just pipeline completion.
+    mockQdrantResults = [
+      {
+        id: "emb-bench-decision",
+        score: 0.9,
+        payload: {
+          target_type: "segment",
+          target_id: "seg-bench-0",
+          text: "Decision 0: use Bun test fixtures for memory regressions and recall ranking checks.",
+          kind: "segment",
+          created_at: now,
+          last_seen_at: now,
+        },
+      },
+    ];
+
     const recall = await buildMemoryRecall(
       "What decisions did we make about Bun tests and retrieval diagnostics?",
       conversationId,
@@ -264,13 +303,13 @@ describe("Memory context benchmark", () => {
       { maxInjectTokensOverride: recallBudget },
     );
 
-    // In CI, Qdrant/embedding providers are unavailable, so semantic search
-    // fails and the retriever marks the result as degraded.  The benchmark
-    // cares about compaction and lexical recall quality, not embedding
-    // availability, so we do not assert on `recall.degraded`.
-    expect(recall.lexicalHits).toBeGreaterThan(0);
+    // 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);
+    expect(recall.injectedText).toContain("Bun test fixtures");
+    expect(recall.injectedTokens).toBeGreaterThan(0);
     expect(recall.injectedTokens).toBeLessThanOrEqual(recallBudget);
     expect(recallBudget).toBeGreaterThanOrEqual(
       recallConfig.memory.retrieval.dynamicBudget.minInjectTokens,
@@ -278,6 +317,5 @@ describe("Memory context benchmark", () => {
     expect(recallBudget).toBeLessThanOrEqual(
       recallConfig.memory.retrieval.dynamicBudget.maxInjectTokens,
     );
-    expect(recall.injectedText).toContain("Bun test fixtures");
   });
 });