@vellumai/assistant 0.8.3 → 0.8.5

package/src/__tests__/log-export-routes.test.ts

@@ -1,8 +1,14 @@
 import { spawnSync } from "node:child_process";
-import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import {
+  existsSync,
+  mkdtempSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { describe, expect, mock, test } from "bun:test";
+import { beforeEach, describe, expect, mock, test } from "bun:test";
 
 mock.module("../util/logger.js", () => ({
   getLogger: () =>
@@ -18,12 +24,23 @@ mock.module("../util/secure-keys.js", () => ({
 import { getDb } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
 import { llmUsageEvents } from "../memory/schema.js";
+import { assistantEventHub } from "../runtime/assistant-event-hub.js";
 import { ROUTES } from "../runtime/routes/log-export-routes.js";
 
 initializeDb();
 
 const exportRoute = ROUTES.find((r) => r.endpoint === "export")!;
 
+function clearConnectedClients(): void {
+  for (const client of assistantEventHub.listClients()) {
+    assistantEventHub.disposeClient(client.clientId);
+  }
+}
+
+beforeEach(() => {
+  clearConnectedClients();
+});
+
 async function extractArchive(bytes: Uint8Array): Promise<string> {
   const extractDir = mkdtempSync(join(tmpdir(), "log-export-routes-"));
   const archivePath = join(extractDir, "archive.tar.gz");
@@ -39,6 +56,86 @@ async function extractArchive(bytes: Uint8Array): Promise<string> {
   return extractDir;
 }
 
+describe("POST /v1/export - connected clients", () => {
+  test("includes current `assistant clients list --json` output", async () => {
+    const subscription = assistantEventHub.subscribe({
+      type: "client",
+      clientId: "client-list-export-test",
+      interfaceId: "macos",
+      capabilities: ["host_bash", "host_file"],
+      machineName: "test-macbook",
+      callback: () => {},
+    });
+
+    try {
+      const result = await exportRoute.handler({ body: {} });
+      expect(result).toBeInstanceOf(Uint8Array);
+
+      const dir = await extractArchive(result as Uint8Array);
+      try {
+        const clientsList = JSON.parse(
+          readFileSync(join(dir, "clients-list.json"), "utf-8"),
+        ) as {
+          clients: Array<{
+            clientId: string;
+            interfaceId: string;
+            capabilities: string[];
+            machineName?: string;
+            connectedAt: string;
+            lastActiveAt: string;
+          }>;
+        };
+
+        expect(clientsList.clients).toHaveLength(1);
+        expect(clientsList.clients[0]).toMatchObject({
+          clientId: "client-list-export-test",
+          interfaceId: "macos",
+          capabilities: ["host_bash", "host_file"],
+          machineName: "test-macbook",
+        });
+        expect(new Date(clientsList.clients[0].connectedAt).toISOString()).toBe(
+          clientsList.clients[0].connectedAt,
+        );
+        expect(
+          new Date(clientsList.clients[0].lastActiveAt).toISOString(),
+        ).toBe(clientsList.clients[0].lastActiveAt);
+      } finally {
+        rmSync(dir, { recursive: true, force: true });
+      }
+    } finally {
+      subscription.dispose();
+    }
+  });
+
+  test("writes a non-blocking error artifact when client listing fails", async () => {
+    const originalListClients = assistantEventHub.listClients;
+    assistantEventHub.listClients = () => {
+      throw new Error("client list unavailable");
+    };
+
+    try {
+      const result = await exportRoute.handler({ body: {} });
+      expect(result).toBeInstanceOf(Uint8Array);
+
+      const dir = await extractArchive(result as Uint8Array);
+      try {
+        expect(existsSync(join(dir, "clients-list.json"))).toBe(false);
+        const errorArtifact = JSON.parse(
+          readFileSync(join(dir, "clients-list-error.json"), "utf-8"),
+        ) as { error: string; collectedAt: string };
+        expect(errorArtifact.error).toBe("client list unavailable");
+        expect(new Date(errorArtifact.collectedAt).toISOString()).toBe(
+          errorArtifact.collectedAt,
+        );
+      } finally {
+        rmSync(dir, { recursive: true, force: true });
+      }
+    } finally {
+      assistantEventHub.listClients = originalListClients;
+    }
+  });
+});
+
 describe("POST /v1/export - LLM usage events", () => {
   test("full export includes usage attribution columns", async () => {
     const db = getDb();

package/src/__tests__/logger.test.ts

@@ -0,0 +1,89 @@
+import { mkdtempSync, readdirSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterAll, describe, expect, test } from "bun:test";
+
+import { getLogger, initLogger, LOG_FILE_PATTERN } from "../util/logger.js";
+
+// ---------------------------------------------------------------------------
+// Test rationale
+// ---------------------------------------------------------------------------
+//
+// `getLogger()` returns a Proxy that lazily creates a pino child against the
+// current rootLogger. Before this PR's refactor, the child was cached on
+// first access and never re-evaluated — which meant that across:
+//
+//   1. day rollover (ensureCurrentDate rebuilds rootLogger past UTC midnight),
+//   2. or a late `initLogger()` call (which swaps the rootLogger),
+//
+// previously-cached children kept writing to the OLD root's destination
+// forever — silently misrouting logs into the wrong daily file.
+//
+// These tests pin the new contract: when the rootLogger changes, the proxy's
+// next access rebuilds the child against the new root.
+//
+// We assert via file-system side effects (logs appearing in the expected
+// directory). pino's `sync: false` default makes the fd open asynchronous,
+// so we wait a tick before reading.
+//
+// NB: the file-creating fallback path itself is gated behind a BUN_TEST=1
+// stderr fast-path in `getRootLogger()` (so test output stays sensible), so
+// these tests exercise the rebind via `initLogger()` calls instead. The
+// "no vellum.log" property is covered by `platform.test.ts` (asserts
+// `getLogsDir()` returns the directory) and by the mechanical guarantee that
+// `buildRotatingLogger` derives filenames via `logFilePathForDate`.
+
+const SLEEP_MS = 100;
+
+const dirA = mkdtempSync(join(tmpdir(), "logger-rebind-A-"));
+const dirB = mkdtempSync(join(tmpdir(), "logger-rebind-B-"));
+
+afterAll(() => {
+  // Detach the module-level rootLogger from the temp dirs we're about to
+  // delete. Without this, a later flush (or the test runner's shutdown)
+  // could try to write into a removed directory.
+  initLogger({ dir: undefined, retentionDays: 0 });
+  rmSync(dirA, { recursive: true, force: true });
+  rmSync(dirB, { recursive: true, force: true });
+});
+
+describe("getLogger() proxy rebind", () => {
+  test("a proxy created BEFORE initLogger() still routes to the post-init root", async () => {
+    // Create the proxy before initLogger has run. This mirrors the real
+    // lifecycle.ts pattern: modules call `getLogger()` at import time, long
+    // before `initLogger()` boots in daemon startup.
+    const log = getLogger("early-binding");
+
+    initLogger({ dir: dirA, retentionDays: 0 });
+
+    log.info("first — should land in dirA");
+
+    await Bun.sleep(SLEEP_MS);
+
+    const aFiles = readdirSync(dirA);
+    expect(aFiles.some((f) => LOG_FILE_PATTERN.test(f))).toBe(true);
+  });
+
+  test("subsequent log calls follow rootLogger swaps from initLogger()", async () => {
+    // rootLogger is currently bound to dirA from the previous test. Reuse
+    // an existing proxy and verify it follows the swap.
+    const log = getLogger("rebind-target");
+    log.info("warm-up against dirA so the child is cached");
+
+    await Bun.sleep(SLEEP_MS);
+
+    // Swap the rootLogger to a different directory.
+    initLogger({ dir: dirB, retentionDays: 0 });
+
+    log.info("post-swap — should land in dirB if the proxy rebound");
+
+    await Bun.sleep(SLEEP_MS);
+
+    // If the proxy correctly re-evaluates getRootLogger() on each access,
+    // the second log call hits the dirB root and dirB gets a daily log
+    // file. If the proxy were still caching the original child against the
+    // dirA root, dirB would stay empty.
+    const bFiles = readdirSync(dirB);
+    expect(bFiles.some((f) => LOG_FILE_PATTERN.test(f))).toBe(true);
+  });
+});

package/src/__tests__/mcp-abort-signal.test.ts

@@ -142,7 +142,7 @@ describe("MCP AbortSignal threading", () => {
       );
 
       expect(tool.name).toBe("mcp__test-server__my-tool");
-      expect(tool.getDefinition().name).toBe("mcp__test-server__my-tool");
+      expect(tool.name).toBe("mcp__test-server__my-tool");
     });
 
     test("keeps MCP tool names with trailing whitespace distinct", () => {
@@ -211,7 +211,7 @@ describe("MCP AbortSignal threading", () => {
       expect(tool.name.startsWith("mcp__stripe_link-cli__create_link__")).toBe(
         true,
       );
-      expect(tool.getDefinition().name).toBe(tool.name);
+      expect(tool.name).toBe(tool.name);
 
       await tool.execute(
         { someArg: "value" },

package/src/__tests__/media-generate-image.test.ts

@@ -321,6 +321,9 @@ describe("image-studio skill script wrapper", () => {
 
     expect(result.isError).toBe(true);
     expect(result.content).toContain("Mock Gemini error: API failure");
+    expect(result.content).toContain(
+      "Do not change service configuration (mode, provider, or model) to try to fix it",
+    );
   });
 
   test("openai generation error uses OpenAI-specific mapping", async () => {
@@ -331,6 +334,34 @@ describe("image-studio skill script wrapper", () => {
 
     expect(result.isError).toBe(true);
     expect(result.content).toContain("Mock OpenAI error: openai failure");
+    expect(result.content).toContain(
+      "Do not change service configuration (mode, provider, or model) to try to fix it",
+    );
+  });
+
+  test("missing credentials error includes guidance not to change service config", async () => {
+    mockGeminiKey = undefined;
+
+    const result = await run({ prompt: "a cat" }, fakeContext);
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain("No Gemini API key");
+    expect(result.content).toContain(
+      "Do not change service configuration (mode, provider, or model) to try to fix it",
+    );
+  });
+
+  test("managed mode credential error includes guidance not to change service config", async () => {
+    mockImageGenMode = "managed";
+    mockManagedBaseUrl = undefined;
+
+    const result = await run({ prompt: "a cat" }, fakeContext);
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain("Managed proxy is not available");
+    expect(result.content).toContain(
+      "Do not change service configuration (mode, provider, or model) to try to fix it",
+    );
   });
 
   test("reads source images from file paths on disk", async () => {

package/src/__tests__/memory-v2-static-injector.test.ts

@@ -4,9 +4,9 @@
  * Covers:
  *   - Returns null when `memoryV2Static` is missing/empty.
  *   - Returns null when `mode === "minimal"`.
- *   - Wraps content in `<memory>...</memory>` and uses
+ *   - Wraps content in `<info>...</info>` and uses
  *     `after-memory-prefix` placement.
- *   - Escapes any `</memory>` substring inside the authored content so the
+ *   - Escapes any `</info>` substring inside the authored content so the
  *     wrapper cannot be broken out of.
  *
  * Hermetic: drives the injector's `produce()` directly with a synthesized
@@ -66,7 +66,7 @@ describe("memory-v2-static injector", () => {
     expect(await memoryV2StaticInjector.produce(ctx)).toBeNull();
   });
 
-  test("wraps content in <memory>...</memory> with after-memory-prefix placement", async () => {
+  test("wraps content in <info>...</info> with after-memory-prefix placement", async () => {
     const content =
       "## Essentials\n\nAlice prefers VS Code.\n\n## Threads\n\nOpen: ship PR.";
     const ctx = makeContext({
@@ -77,11 +77,11 @@ describe("memory-v2-static injector", () => {
     expect(block).not.toBeNull();
     expect(block!.id).toBe("memory-v2-static");
     expect(block!.placement).toBe("after-memory-prefix");
-    expect(block!.text).toBe(`<memory>\n${content}\n</memory>`);
+    expect(block!.text).toBe(`<info>\n${content}\n</info>`);
   });
 
-  test("escapes inner </memory> closing tags so the wrapper cannot be broken out of", async () => {
-    const content = "## Essentials\n\nText with </memory> embedded.";
+  test("escapes inner </info> closing tags so the wrapper cannot be broken out of", async () => {
+    const content = "## Essentials\n\nText with </info> embedded.";
     const ctx = makeContext({
       injectionInputs: { memoryV2Static: content },
     });
@@ -89,7 +89,7 @@ describe("memory-v2-static injector", () => {
     const block = await memoryV2StaticInjector.produce(ctx);
     expect(block).not.toBeNull();
     expect(block!.text).toBe(
-      "<memory>\n## Essentials\n\nText with &lt;/memory&gt; embedded.\n</memory>",
+      "<info>\n## Essentials\n\nText with &lt;/info&gt; embedded.\n</info>",
     );
   });
 });

package/src/__tests__/message-queue-steer.test.ts

@@ -0,0 +1,114 @@
+import { describe, expect, test } from "bun:test";
+
+import {
+  MessageQueue,
+  type QueuedMessage,
+} from "../daemon/conversation-queue-manager.js";
+
+function makeItem(content: string, requestId: string): QueuedMessage {
+  return {
+    content,
+    attachments: [],
+    requestId,
+    onEvent: () => {},
+    sentAt: Date.now(),
+  };
+}
+
+describe("MessageQueue.promoteToHead", () => {
+  test("returns undefined when queue is empty", () => {
+    const q = new MessageQueue();
+    expect(q.promoteToHead("nonexistent")).toBeUndefined();
+  });
+
+  test("returns undefined when requestId is not found", () => {
+    const q = new MessageQueue();
+    q.push(makeItem("a", "r1"));
+    q.push(makeItem("b", "r2"));
+    expect(q.promoteToHead("r99")).toBeUndefined();
+    // Queue unchanged
+    expect(q.peek(0)?.requestId).toBe("r1");
+    expect(q.peek(1)?.requestId).toBe("r2");
+  });
+
+  test("no-op when the message is already at head", () => {
+    const q = new MessageQueue();
+    q.push(makeItem("a", "r1"));
+    q.push(makeItem("b", "r2"));
+
+    const bytesBefore = q.totalBytes;
+    const result = q.promoteToHead("r1");
+
+    expect(result).toBeDefined();
+    expect(result?.requestId).toBe("r1");
+    expect(q.peek(0)?.requestId).toBe("r1");
+    expect(q.peek(1)?.requestId).toBe("r2");
+    expect(q.length).toBe(2);
+    expect(q.totalBytes).toBe(bytesBefore);
+  });
+
+  test("moves a middle item to head", () => {
+    const q = new MessageQueue();
+    q.push(makeItem("a", "r1"));
+    q.push(makeItem("b", "r2"));
+    q.push(makeItem("c", "r3"));
+
+    const bytesBefore = q.totalBytes;
+    const result = q.promoteToHead("r2");
+
+    expect(result).toBeDefined();
+    expect(result?.requestId).toBe("r2");
+    expect(q.peek(0)?.requestId).toBe("r2");
+    expect(q.peek(1)?.requestId).toBe("r1");
+    expect(q.peek(2)?.requestId).toBe("r3");
+    expect(q.length).toBe(3);
+    expect(q.totalBytes).toBe(bytesBefore);
+  });
+
+  test("moves the last item to head", () => {
+    const q = new MessageQueue();
+    q.push(makeItem("a", "r1"));
+    q.push(makeItem("b", "r2"));
+    q.push(makeItem("c", "r3"));
+
+    const bytesBefore = q.totalBytes;
+    const result = q.promoteToHead("r3");
+
+    expect(result).toBeDefined();
+    expect(result?.requestId).toBe("r3");
+    expect(q.peek(0)?.requestId).toBe("r3");
+    expect(q.peek(1)?.requestId).toBe("r1");
+    expect(q.peek(2)?.requestId).toBe("r2");
+    expect(q.length).toBe(3);
+    expect(q.totalBytes).toBe(bytesBefore);
+  });
+
+  test("byte accounting unchanged after promote (item is reordered, not added/removed)", () => {
+    const q = new MessageQueue(10_000);
+    q.push(makeItem("short", "r1"));
+    q.push(makeItem("a".repeat(200), "r2"));
+    q.push(makeItem("medium text", "r3"));
+
+    const bytesBefore = q.totalBytes;
+    q.promoteToHead("r2");
+    expect(q.totalBytes).toBe(bytesBefore);
+
+    // shift all and verify bytes go to 0
+    q.shift();
+    q.shift();
+    q.shift();
+    expect(q.totalBytes).toBe(0);
+  });
+
+  test("promoted item is returned by shift()", () => {
+    const q = new MessageQueue();
+    q.push(makeItem("a", "r1"));
+    q.push(makeItem("b", "r2"));
+    q.push(makeItem("c", "r3"));
+
+    q.promoteToHead("r3");
+    const head = q.shift();
+    expect(head?.requestId).toBe("r3");
+    expect(head?.content).toBe("c");
+  });
+});

package/src/__tests__/model-intents.test.ts

@@ -29,7 +29,7 @@ describe("model intents", () => {
       "gpt-5.4-nano",
     );
     expect(resolveModelIntent("gemini", "latency-optimized")).toBe(
-      "gemini-3.1-flash-lite-preview",
+      "gemini-3.1-flash-lite",
     );
     expect(resolveModelIntent("gemini", "quality-optimized")).toBe(
       "gemini-3.1-pro-preview",
@@ -44,9 +44,7 @@ describe("model intents", () => {
   });
 
   test("falls back to provider default for unknown providers", () => {
-    expect(getProviderDefaultModel("unknown-provider")).toBe(
-      "claude-opus-4-7",
-    );
+    expect(getProviderDefaultModel("unknown-provider")).toBe("claude-opus-4-7");
     expect(resolveModelIntent("unknown-provider", "quality-optimized")).toBe(
       "claude-opus-4-7",
     );

package/src/__tests__/notification-guardian-path.test.ts

@@ -66,7 +66,6 @@ mock.module("../notifications/emit-signal.js", () => ({
     }
     return mockEmitResult;
   },
-  registerBroadcastFn: () => {},
 }));
 
 import {

package/src/__tests__/onboarding-template-contract.test.ts

@@ -44,7 +44,7 @@ describe("onboarding template contracts", () => {
     test("instructs saving to IDENTITY.md, SOUL.md, and user persona file via file_edit", () => {
       expect(bootstrap).toContain("IDENTITY.md");
       expect(bootstrap).toContain("SOUL.md");
-      expect(bootstrap).toContain("{{USER_PERSONA_FILE}}");
+      expect(bootstrap).toContain("{{userSlug}}.md");
       expect(bootstrap).toContain("file_edit");
     });