@vellumai/assistant 0.8.7 → 0.8.8-dev.202606052332.17fc8ea

package/src/__tests__/conversation-title-service.test.ts

@@ -51,9 +51,18 @@ mock.module("../util/logger.js", () => ({
     }),
 }));
 
+const mockPublishConversationTitleChanged = mock(
+  (_conversationId: string, _title: string) => {},
+);
+mock.module("../runtime/sync/resource-sync-events.js", () => ({
+  publishConversationTitleChanged: mockPublishConversationTitleChanged,
+}));
+
 import {
   generateAndPersistConversationTitle,
+  queueGenerateConversationTitle,
   regenerateConversationTitle,
+  titleMutex,
 } from "../memory/conversation-title-service.js";
 
 describe("conversation-title-service", () => {
@@ -63,6 +72,7 @@ describe("conversation-title-service", () => {
     mockGetMessages.mockClear();
     mockUpdateConversationTitle.mockClear();
     mockGetConfiguredProvider.mockClear();
+    mockPublishConversationTitleChanged.mockClear();
   });
 
   test("uses the BTW side-chain helper for initial title generation", async () => {
@@ -87,7 +97,7 @@ describe("conversation-title-service", () => {
         systemPrompt: expect.stringContaining("conversation titles"),
         tools: [],
         callSite: "conversationTitle",
-        timeoutMs: 10_000,
+        timeoutMs: 15_000,
       }),
     );
     expect(mockUpdateConversationTitle).toHaveBeenCalledWith(
@@ -95,6 +105,12 @@ describe("conversation-title-service", () => {
       "Project kickoff",
       1,
     );
+    // Emit is service-native: persisting a title broadcasts the update so
+    // every title origin (agent loop, bootstrap, voice) updates clients live.
+    expect(mockPublishConversationTitleChanged).toHaveBeenCalledWith(
+      "conv-1",
+      "Project kickoff",
+    );
   });
 
   test("regeneration extracts text from JSON content blocks", async () => {
@@ -205,7 +221,7 @@ describe("conversation-title-service", () => {
         systemPrompt: expect.stringContaining("conversation titles"),
         tools: [],
         callSite: "conversationTitle",
-        timeoutMs: 10_000,
+        timeoutMs: 15_000,
       }),
     );
     expect(mockUpdateConversationTitle).toHaveBeenCalledWith(
@@ -354,4 +370,121 @@ describe("conversation-title-service", () => {
     expect(call.content).not.toContain("do NOT respond");
     expect(call.systemPrompt).toContain("Do NOT respond");
   });
+
+  test("queueGenerateConversationTitle serializes concurrent calls", async () => {
+    const callOrder: string[] = [];
+    let resolveFirst!: () => void;
+    const firstBlocked = new Promise<void>((r) => {
+      resolveFirst = r;
+    });
+
+    // First call: blocks until we release it
+    mockRunBtwSidechain.mockImplementationOnce(async () => {
+      callOrder.push("first:start");
+      await firstBlocked;
+      callOrder.push("first:end");
+      return {
+        text: "Title One",
+        hadTextDeltas: true,
+        response: {
+          content: [{ type: "text", text: "Title One" }],
+          model: "test-model",
+          usage: { inputTokens: 10, outputTokens: 5 },
+          stopReason: "end_turn",
+        },
+      };
+    });
+
+    // Second call: resolves immediately
+    mockRunBtwSidechain.mockImplementationOnce(async () => {
+      callOrder.push("second:start");
+      return {
+        text: "Title Two",
+        hadTextDeltas: true,
+        response: {
+          content: [{ type: "text", text: "Title Two" }],
+          model: "test-model",
+          usage: { inputTokens: 10, outputTokens: 5 },
+          stopReason: "end_turn",
+        },
+      };
+    });
+
+    const provider = {
+      name: "test-provider",
+      sendMessage: mock(async () => {
+        throw new Error("should not call directly");
+      }),
+    };
+
+    // Fire both calls — without serialization both would start immediately
+    queueGenerateConversationTitle({
+      conversationId: "conv-1",
+      provider,
+      userMessage: "first message",
+    });
+    queueGenerateConversationTitle({
+      conversationId: "conv-2",
+      provider,
+      userMessage: "second message",
+    });
+
+    // Let microtasks settle — only the first call should have started
+    await new Promise((r) => setTimeout(r, 10));
+    expect(callOrder).toEqual(["first:start"]);
+
+    // Release the first call
+    resolveFirst();
+    await titleMutex.withLock(async () => {});
+
+    // Second should have started only after first finished
+    expect(callOrder).toEqual(["first:start", "first:end", "second:start"]);
+  });
+
+  test("queue continues processing after a failed call", async () => {
+    // First call: throws
+    mockRunBtwSidechain.mockImplementationOnce(async () => {
+      throw new Error("provider timeout");
+    });
+
+    // Second call: succeeds
+    mockRunBtwSidechain.mockImplementationOnce(async () => ({
+      text: "Recovery Title",
+      hadTextDeltas: true,
+      response: {
+        content: [{ type: "text", text: "Recovery Title" }],
+        model: "test-model",
+        usage: { inputTokens: 10, outputTokens: 5 },
+        stopReason: "end_turn",
+      },
+    }));
+
+    const provider = {
+      name: "test-provider",
+      sendMessage: mock(async () => {
+        throw new Error("should not call directly");
+      }),
+    };
+
+    queueGenerateConversationTitle({
+      conversationId: "conv-1",
+      provider,
+      userMessage: "will fail",
+    });
+    queueGenerateConversationTitle({
+      conversationId: "conv-2",
+      provider,
+      userMessage: "will succeed",
+    });
+
+    await titleMutex.withLock(async () => {});
+
+    // Both calls went through — failure didn't break the chain
+    expect(mockRunBtwSidechain).toHaveBeenCalledTimes(2);
+    // Second conversation got a proper title
+    const secondUpdate = (
+      mockUpdateConversationTitle.mock.calls as unknown as string[][]
+    ).find((c) => c[0] === "conv-2" && c[1] === "Recovery Title");
+    expect(secondUpdate).toBeTruthy();
+  });
 });

package/src/__tests__/conversation-workspace-cache-state.test.ts

@@ -198,6 +198,7 @@ mock.module("../agent/loop.js", () => ({
 }));
 
 import { Conversation } from "../daemon/conversation.js";
+import { refreshWorkspaceTopLevelContextIfNeeded } from "../daemon/conversation-workspace.js";
 
 // ---------------------------------------------------------------------------
 // Helpers
@@ -249,7 +250,7 @@ describe("Conversation workspace cache state", () => {
   });
 
   test("refreshWorkspaceTopLevelContextIfNeeded populates context and clears dirty", () => {
-    conversation.refreshWorkspaceTopLevelContextIfNeeded();
+    refreshWorkspaceTopLevelContextIfNeeded(conversation);
 
     expect(conversation.isWorkspaceTopLevelDirty()).toBe(false);
     expect(conversation.getWorkspaceTopLevelContext()).not.toBeNull();
@@ -265,10 +266,10 @@ describe("Conversation workspace cache state", () => {
   });
 
   test("refreshWorkspaceTopLevelContextIfNeeded no-ops when not dirty and cache exists", () => {
-    conversation.refreshWorkspaceTopLevelContextIfNeeded();
+    refreshWorkspaceTopLevelContextIfNeeded(conversation);
     const first = conversation.getWorkspaceTopLevelContext();
 
-    conversation.refreshWorkspaceTopLevelContextIfNeeded();
+    refreshWorkspaceTopLevelContextIfNeeded(conversation);
     const second = conversation.getWorkspaceTopLevelContext();
 
     // Same reference — no recomputation
@@ -276,7 +277,7 @@ describe("Conversation workspace cache state", () => {
   });
 
   test("markWorkspaceTopLevelDirty sets dirty flag", () => {
-    conversation.refreshWorkspaceTopLevelContextIfNeeded();
+    refreshWorkspaceTopLevelContextIfNeeded(conversation);
     expect(conversation.isWorkspaceTopLevelDirty()).toBe(false);
 
     conversation.markWorkspaceTopLevelDirty();
@@ -284,10 +285,10 @@ describe("Conversation workspace cache state", () => {
   });
 
   test("refresh after marking dirty produces fresh context", () => {
-    conversation.refreshWorkspaceTopLevelContextIfNeeded();
+    refreshWorkspaceTopLevelContextIfNeeded(conversation);
 
     conversation.markWorkspaceTopLevelDirty();
-    conversation.refreshWorkspaceTopLevelContextIfNeeded();
+    refreshWorkspaceTopLevelContextIfNeeded(conversation);
 
     expect(conversation.getWorkspaceTopLevelContext()).not.toBeNull();
     expect(conversation.getWorkspaceTopLevelContext()!).toContain(
@@ -299,7 +300,7 @@ describe("Conversation workspace cache state", () => {
   test("renders client-reported host env when set on the conversation", () => {
     conversation.hostHomeDir = "/Users/alice";
     conversation.hostUsername = "alice";
-    conversation.refreshWorkspaceTopLevelContextIfNeeded();
+    refreshWorkspaceTopLevelContextIfNeeded(conversation);
 
     const block = conversation.getWorkspaceTopLevelContext();
     expect(block).not.toBeNull();
@@ -309,7 +310,7 @@ describe("Conversation workspace cache state", () => {
 
   test("falls back to daemon os info when client host env is absent", async () => {
     const { homedir, userInfo } = await import("node:os");
-    conversation.refreshWorkspaceTopLevelContextIfNeeded();
+    refreshWorkspaceTopLevelContextIfNeeded(conversation);
 
     const block = conversation.getWorkspaceTopLevelContext();
     expect(block).not.toBeNull();
@@ -320,7 +321,7 @@ describe("Conversation workspace cache state", () => {
   test("re-renders with updated host env after marking dirty", () => {
     conversation.hostHomeDir = "/Users/alice";
     conversation.hostUsername = "alice";
-    conversation.refreshWorkspaceTopLevelContextIfNeeded();
+    refreshWorkspaceTopLevelContextIfNeeded(conversation);
     expect(conversation.getWorkspaceTopLevelContext()!).toContain(
       "Host home directory: /Users/alice",
     );
@@ -328,7 +329,7 @@ describe("Conversation workspace cache state", () => {
     conversation.hostHomeDir = "/Users/bob";
     conversation.hostUsername = "bob";
     conversation.markWorkspaceTopLevelDirty();
-    conversation.refreshWorkspaceTopLevelContextIfNeeded();
+    refreshWorkspaceTopLevelContextIfNeeded(conversation);
 
     const block = conversation.getWorkspaceTopLevelContext();
     expect(block).not.toBeNull();
@@ -344,7 +345,7 @@ describe("Conversation workspace cache state", () => {
     // Simulate a macOS turn populating host env.
     conversation.hostHomeDir = "/Users/alice";
     conversation.hostUsername = "alice";
-    conversation.refreshWorkspaceTopLevelContextIfNeeded();
+    refreshWorkspaceTopLevelContextIfNeeded(conversation);
     expect(conversation.getWorkspaceTopLevelContext()!).toContain(
       "Host home directory: /Users/alice",
     );
@@ -355,7 +356,7 @@ describe("Conversation workspace cache state", () => {
     conversation.hostHomeDir = undefined;
     conversation.hostUsername = undefined;
     conversation.markWorkspaceTopLevelDirty();
-    conversation.refreshWorkspaceTopLevelContextIfNeeded();
+    refreshWorkspaceTopLevelContextIfNeeded(conversation);
 
     const block = conversation.getWorkspaceTopLevelContext();
     expect(block).not.toBeNull();
@@ -381,7 +382,7 @@ describe("Conversation workspace cache state", () => {
     expect(conversation.hostUsername).toBe("alice");
     expect(conversation.isWorkspaceTopLevelDirty()).toBe(true);
 
-    conversation.refreshWorkspaceTopLevelContextIfNeeded();
+    refreshWorkspaceTopLevelContextIfNeeded(conversation);
     const block = conversation.getWorkspaceTopLevelContext();
     expect(block!).toContain("Host home directory: /Users/alice");
     expect(block!).toContain("Host username: alice");
@@ -455,7 +456,7 @@ describe("Conversation workspace cache state", () => {
       hostUsername: "alice",
     });
     // Render once so the dirty flag clears.
-    conversation.refreshWorkspaceTopLevelContextIfNeeded();
+    refreshWorkspaceTopLevelContextIfNeeded(conversation);
     expect(conversation.isWorkspaceTopLevelDirty()).toBe(false);
 
     // Re-apply the same values — dirty flag should remain false so we don't
@@ -476,7 +477,7 @@ describe("Conversation workspace cache state", () => {
       hostHomeDir: "/Users/alice",
       hostUsername: "alice",
     });
-    conversation.refreshWorkspaceTopLevelContextIfNeeded();
+    refreshWorkspaceTopLevelContextIfNeeded(conversation);
     expect(conversation.isWorkspaceTopLevelDirty()).toBe(false);
 
     // New values — should mark dirty so the next render picks them up.
@@ -500,7 +501,7 @@ describe("Conversation workspace cache state", () => {
 
     try {
       const tempConversation = makeConversation(workspaceRoot);
-      tempConversation.refreshWorkspaceTopLevelContextIfNeeded();
+      refreshWorkspaceTopLevelContextIfNeeded(tempConversation);
 
       expect(tempConversation.getWorkspaceTopLevelContext()!).toContain(
         `Current conversation attachments: conversations/${legacyDirName}/attachments/`,

package/src/__tests__/conversation-workspace-injection.test.ts

@@ -265,7 +265,12 @@ mock.module("../agent/loop.js", () => ({
         content: [{ type: "text", text: "ok" }],
       };
       onEvent({ type: "message_complete", message: assistantMessage });
-      return { history: [...messages, assistantMessage], exitReason: null };
+      return {
+        history: [...messages, assistantMessage],
+        exitReason: null,
+        appendedNewMessages: true,
+        newMessages: [assistantMessage],
+      };
     }
   },
 }));
@@ -290,6 +295,14 @@ mock.module("../memory/canonical-guardian-store.js", () => ({
 }));
 
 import { Conversation } from "../daemon/conversation.js";
+import {
+  clearConversations,
+  findConversation,
+  removeSubagentConversation,
+  setConversation,
+  setSubagentConversation,
+} from "../daemon/conversation-registry.js";
+import { resolveWorkspaceTopLevelContext } from "../daemon/conversation-workspace.js";
 import { resetPluginRegistryAndRegisterDefaults } from "../plugins/defaults/index.js";
 
 function makeConversation(): Conversation {
@@ -304,7 +317,7 @@ function makeConversation(): Conversation {
       };
     },
   };
-  return new Conversation(
+  const conversation = new Conversation(
     "conv-1",
     provider,
     "system prompt",
@@ -312,6 +325,10 @@ function makeConversation(): Conversation {
     "/tmp",
     { maxTokens: 4096 },
   );
+  // Mirror production: top-level conversations are registered in the store, so
+  // the workspace injector can resolve them by id via the conversation registry.
+  setConversation(conversation.conversationId, conversation);
+  return conversation;
 }
 
 function messageText(message: Message): string {
@@ -330,6 +347,7 @@ describe("Conversation workspace injection", () => {
     runCalls = [];
     agentLoopScript = () => {};
     scanCallCount = 0;
+    clearConversations();
     resetPluginRegistryAndRegisterDefaults();
   });
 
@@ -412,11 +430,58 @@ describe("Conversation workspace injection", () => {
   });
 });
 
+describe("Conversation workspace injection — subagents", () => {
+  beforeEach(() => {
+    scanCallCount = 0;
+    clearConversations();
+    resetPluginRegistryAndRegisterDefaults();
+  });
+
+  test("workspace context resolves for subagent conversations not in the store", () => {
+    const provider = {
+      name: "mock",
+      async sendMessage(): Promise<ProviderResponse> {
+        return {
+          content: [],
+          model: "mock",
+          usage: { inputTokens: 0, outputTokens: 0 },
+          stopReason: "end_turn",
+        };
+      },
+    };
+    const subagentId = "subagent-conv-1";
+    const conversation = new Conversation(
+      subagentId,
+      provider,
+      "system prompt",
+      () => {},
+      "/tmp",
+      { maxTokens: 4096 },
+    );
+    setSubagentConversation(subagentId, conversation);
+
+    try {
+      // Subagents live only in the manager's index, never in the
+      // eviction-managed store, so the store lookup must not see them.
+      expect(findConversation(subagentId)).toBeUndefined();
+
+      // The per-conversation workspace lookup still resolves them, so subagent
+      // turns retain workspace grounding.
+      const context = resolveWorkspaceTopLevelContext(subagentId);
+      expect(context).not.toBeNull();
+      expect(context).toContain("Root: /tmp");
+    } finally {
+      removeSubagentConversation(subagentId, conversation);
+    }
+  });
+});
+
 describe("Conversation workspace dirty-refresh E2E", () => {
   beforeEach(() => {
     runCalls = [];
     agentLoopScript = () => {};
     scanCallCount = 0;
+    clearConversations();
     resetPluginRegistryAndRegisterDefaults();
   });
 

package/src/__tests__/conversation-workspace-tool-tracking.test.ts

@@ -273,6 +273,7 @@ mock.module("../memory/canonical-guardian-store.js", () => ({
 }));
 
 import { Conversation } from "../daemon/conversation.js";
+import { refreshWorkspaceTopLevelContextIfNeeded } from "../daemon/conversation-workspace.js";
 
 function makeConversation(): Conversation {
   const provider = {
@@ -310,7 +311,7 @@ describe("Conversation workspace dirty on file mutations", () => {
     await conversation.loadFromDb();
 
     // Prime the cache so dirty=false
-    conversation.refreshWorkspaceTopLevelContextIfNeeded();
+    refreshWorkspaceTopLevelContextIfNeeded(conversation);
     expect(conversation.isWorkspaceTopLevelDirty()).toBe(false);
 
     agentLoopScript = (onEvent) => {
@@ -339,7 +340,7 @@ describe("Conversation workspace dirty on file mutations", () => {
     const conversation = makeConversation();
     await conversation.loadFromDb();
 
-    conversation.refreshWorkspaceTopLevelContextIfNeeded();
+    refreshWorkspaceTopLevelContextIfNeeded(conversation);
     expect(conversation.isWorkspaceTopLevelDirty()).toBe(false);
 
     agentLoopScript = (onEvent) => {
@@ -370,7 +371,7 @@ describe("Conversation workspace dirty on file mutations", () => {
     const conversation = makeConversation();
     await conversation.loadFromDb();
 
-    conversation.refreshWorkspaceTopLevelContextIfNeeded();
+    refreshWorkspaceTopLevelContextIfNeeded(conversation);
     expect(conversation.isWorkspaceTopLevelDirty()).toBe(false);
 
     agentLoopScript = (onEvent) => {
@@ -399,7 +400,7 @@ describe("Conversation workspace dirty on file mutations", () => {
     const conversation = makeConversation();
     await conversation.loadFromDb();
 
-    conversation.refreshWorkspaceTopLevelContextIfNeeded();
+    refreshWorkspaceTopLevelContextIfNeeded(conversation);
     expect(conversation.isWorkspaceTopLevelDirty()).toBe(false);
 
     agentLoopScript = (onEvent) => {
@@ -428,7 +429,7 @@ describe("Conversation workspace dirty on file mutations", () => {
     const conversation = makeConversation();
     await conversation.loadFromDb();
 
-    conversation.refreshWorkspaceTopLevelContextIfNeeded();
+    refreshWorkspaceTopLevelContextIfNeeded(conversation);
     expect(conversation.isWorkspaceTopLevelDirty()).toBe(false);
 
     agentLoopScript = (onEvent) => {
@@ -457,7 +458,7 @@ describe("Conversation workspace dirty on file mutations", () => {
     const conversation = makeConversation();
     await conversation.loadFromDb();
 
-    conversation.refreshWorkspaceTopLevelContextIfNeeded();
+    refreshWorkspaceTopLevelContextIfNeeded(conversation);
     expect(conversation.isWorkspaceTopLevelDirty()).toBe(false);
 
     agentLoopScript = (onEvent) => {

package/src/__tests__/conversations-import-system-filter.test.ts

@@ -0,0 +1,101 @@
+/**
+ * Tests that the conversations import route never persists non-renderable
+ * roles. The messages store is UI-facing (`ConversationMessage`), so an
+ * imported export carrying agent-context `system` rows must land only its
+ * `user`/`assistant` turns — the `system` rows are dropped, not persisted.
+ */
+
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+mock.module("../config/loader.js", () => ({
+  getConfig: () => ({
+    ui: {},
+    model: "test",
+    provider: "test",
+    memory: { enabled: false },
+    rateLimit: { maxRequestsPerMinute: 0 },
+  }),
+}));
+
+mock.module("../memory/indexer.js", () => ({
+  indexMessageNow: async () => {},
+}));
+
+import { getMessages } from "../memory/conversation-crud.js";
+import { getDb } from "../memory/db-connection.js";
+import { initializeDb } from "../memory/db-init.js";
+import { conversations, messages } from "../memory/schema.js";
+import { ROUTES } from "../runtime/routes/conversations-import-routes.js";
+import type { RouteHandlerArgs } from "../runtime/routes/types.js";
+
+initializeDb();
+
+function resetTables() {
+  const db = getDb();
+  db.run("DELETE FROM message_attachments");
+  db.run("DELETE FROM attachments");
+  db.run("DELETE FROM messages");
+  db.run("DELETE FROM conversation_keys");
+  db.run("DELETE FROM conversations");
+}
+
+const importHandler = ROUTES.find(
+  (r) => r.operationId === "conversations_import",
+)!.handler;
+
+describe("conversations import system-row filtering", () => {
+  beforeEach(resetTables);
+
+  test("imports renderable turns but drops system rows", async () => {
+    // GIVEN an export whose conversation sandwiches a system row between two
+    // renderable turns (e.g. agent-context scaffolding an export carried)
+    const body = {
+      conversations: [
+        {
+          sourceKey: "src-1",
+          title: "Imported chat",
+          messages: [
+            { role: "user", content: "first visible" },
+            { role: "system", content: "agent-context scaffolding" },
+            { role: "assistant", content: "second visible" },
+          ],
+        },
+      ],
+    };
+
+    // WHEN the conversation is imported
+    const result = (await importHandler({
+      body,
+    } as unknown as RouteHandlerArgs)) as {
+      ok: boolean;
+      imported: number;
+      messages: number;
+    };
+
+    // THEN the import succeeds and only counts the renderable turns
+    expect(result.ok).toBe(true);
+    expect(result.imported).toBe(1);
+    expect(result.messages).toBe(2);
+
+    // AND the persisted rows are exactly the user/assistant turns, never the
+    // system scaffolding
+    const db = getDb();
+    const conv = db.select().from(conversations).all()[0];
+    const rows = getMessages(conv.id);
+    expect(rows.map((m) => m.role)).toEqual(["user", "assistant"]);
+    expect(
+      db
+        .select()
+        .from(messages)
+        .all()
+        .some((m) => m.role === "system"),
+    ).toBe(false);
+  });
+});