@vellumai/assistant 0.6.6 → 0.7.0

package/src/__tests__/conversation-store.test.ts

@@ -1,8 +1,5 @@
-import { Database } from "bun:sqlite";
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
-import { drizzle } from "drizzle-orm/bun-sqlite";
-
 mock.module("../util/logger.js", () => ({
   getLogger: () =>
     new Proxy({} as Record<string, unknown>, {
@@ -22,28 +19,15 @@ import {
   createConversation,
   deleteLastExchange,
   getConversation,
-  getConversationHostAccess,
   getConversationMemoryScopeId,
-  getConversationType,
   getMessages,
-  updateConversationHostAccess,
 } from "../memory/conversation-crud.js";
 import { isLastUserMessageToolResult } from "../memory/conversation-queries.js";
-import { getDb, initializeDb } from "../memory/db.js";
-import { getSqliteFrom } from "../memory/db-connection.js";
-import { migrateConversationHostAccess } from "../memory/migrations/217-conversation-host-access.js";
-import * as schema from "../memory/schema.js";
-
+import { getDb } from "../memory/db-connection.js";
+import { initializeDb } from "../memory/db-init.js";
 // Initialize db once before all tests
 initializeDb();
 
-function createMigrationTestDb() {
-  const sqlite = new Database(":memory:");
-  sqlite.exec("PRAGMA journal_mode=WAL");
-  sqlite.exec("PRAGMA foreign_keys = ON");
-  return drizzle(sqlite, { schema });
-}
-
 describe("deleteLastExchange", () => {
   beforeEach(() => {
     // Reset database between tests by dropping and recreating tables
@@ -421,7 +405,6 @@ describe("conversation metadata defaults", () => {
     expect(loaded).not.toBeNull();
     expect(loaded!.conversationType).toBe("standard");
     expect(loaded!.memoryScopeId).toBe("default");
-    expect(loaded!.hostAccess).toBe(0);
   });
 
   test("existing conversations without explicit values get defaults via migration", () => {
@@ -438,7 +421,6 @@ describe("conversation metadata defaults", () => {
     expect(loaded).not.toBeNull();
     expect(loaded!.conversationType).toBe("standard");
     expect(loaded!.memoryScopeId).toBe("default");
-    expect(loaded!.hostAccess).toBe(0);
   });
 });
 
@@ -465,23 +447,6 @@ describe("createConversation with conversation type option", () => {
     expect(conv.memoryScopeId).toBe("default");
   });
 
-  test("private create sets conversationType and derives memoryScopeId", () => {
-    const conv = createConversation({
-      title: "secret",
-      conversationType: "private",
-    });
-    expect(conv.conversationType).toBe("private");
-    expect(conv.memoryScopeId).toBe(`private:${conv.id}`);
-  });
-
-  test("private create memoryScopeId is persisted", () => {
-    const conv = createConversation({ conversationType: "private" });
-    const loaded = getConversation(conv.id);
-    expect(loaded).not.toBeNull();
-    expect(loaded!.conversationType).toBe("private");
-    expect(loaded!.memoryScopeId).toBe(`private:${conv.id}`);
-  });
-
   test("no-arg create uses defaults", () => {
     const conv = createConversation();
     expect(conv.conversationType).toBe("standard");
@@ -496,211 +461,14 @@ describe("conversation metadata read helpers", () => {
     db.run(`DELETE FROM conversations`);
   });
 
-  test("getConversationType returns standard for standard conversation", () => {
-    const conv = createConversation("test");
-    expect(getConversationType(conv.id)).toBe("standard");
-  });
-
-  test("getConversationType returns private for private conversation", () => {
-    const conv = createConversation({ conversationType: "private" });
-    expect(getConversationType(conv.id)).toBe("private");
-  });
-
-  test("getConversationType returns standard for missing conversation", () => {
-    expect(getConversationType("nonexistent-id")).toBe("standard");
-  });
-
   test("getConversationMemoryScopeId returns default for standard conversation", () => {
     const conv = createConversation("test");
     expect(getConversationMemoryScopeId(conv.id)).toBe("default");
   });
 
-  test("getConversationMemoryScopeId returns private scope for private conversation", () => {
-    const conv = createConversation({ conversationType: "private" });
-    expect(getConversationMemoryScopeId(conv.id)).toBe(`private:${conv.id}`);
-  });
-
   test("getConversationMemoryScopeId returns default for missing conversation", () => {
     expect(getConversationMemoryScopeId("nonexistent-id")).toBe("default");
   });
-
-  test("getConversationHostAccess returns false by default", () => {
-    const conv = createConversation("test");
-    expect(getConversationHostAccess(conv.id)).toBe(false);
-  });
-
-  test("getConversationHostAccess returns false for missing conversation", () => {
-    expect(getConversationHostAccess("nonexistent-id")).toBe(false);
-  });
-});
-
-describe("conversation host access persistence", () => {
-  beforeEach(() => {
-    const db = getDb();
-    db.run(`DELETE FROM messages`);
-    db.run(`DELETE FROM conversations`);
-  });
-
-  test("new conversations default host access to disabled", () => {
-    const conv = createConversation("test");
-    const loaded = getConversation(conv.id);
-
-    expect(conv.hostAccess).toBe(0);
-    expect(loaded).not.toBeNull();
-    expect(loaded!.hostAccess).toBe(0);
-    expect(getConversationHostAccess(conv.id)).toBe(false);
-  });
-
-  test("updateConversationHostAccess persists mutations", () => {
-    const conv = createConversation("test");
-
-    updateConversationHostAccess(conv.id, true);
-    expect(getConversationHostAccess(conv.id)).toBe(true);
-    expect(getConversation(conv.id)?.hostAccess).toBe(1);
-
-    updateConversationHostAccess(conv.id, false);
-    expect(getConversationHostAccess(conv.id)).toBe(false);
-    expect(getConversation(conv.id)?.hostAccess).toBe(0);
-  });
-});
-
-describe("conversation host access migration", () => {
-  function bootstrapPreHostAccessConversations(raw: Database): void {
-    raw.exec(/*sql*/ `
-      CREATE TABLE memory_checkpoints (
-        key TEXT PRIMARY KEY,
-        value TEXT NOT NULL,
-        updated_at INTEGER NOT NULL
-      )
-    `);
-
-    raw.exec(/*sql*/ `
-      CREATE TABLE conversations (
-        id TEXT PRIMARY KEY,
-        title TEXT,
-        created_at INTEGER NOT NULL,
-        updated_at INTEGER NOT NULL,
-        total_input_tokens INTEGER NOT NULL DEFAULT 0,
-        total_output_tokens INTEGER NOT NULL DEFAULT 0,
-        total_estimated_cost REAL NOT NULL DEFAULT 0,
-        context_summary TEXT,
-        context_compacted_message_count INTEGER NOT NULL DEFAULT 0,
-        context_compacted_at INTEGER,
-        conversation_type TEXT NOT NULL DEFAULT 'standard',
-        source TEXT NOT NULL DEFAULT 'user',
-        memory_scope_id TEXT NOT NULL DEFAULT 'default',
-        origin_channel TEXT,
-        origin_interface TEXT,
-        fork_parent_conversation_id TEXT,
-        fork_parent_message_id TEXT,
-        is_auto_title INTEGER NOT NULL DEFAULT 1,
-        schedule_job_id TEXT,
-        last_message_at INTEGER
-      )
-    `);
-  }
-
-  test("migration adds host access with disabled default for existing rows", () => {
-    const db = createMigrationTestDb();
-    const raw = getSqliteFrom(db);
-    const now = Date.now();
-
-    bootstrapPreHostAccessConversations(raw);
-    raw.exec(/*sql*/ `
-      INSERT INTO conversations (
-        id,
-        title,
-        created_at,
-        updated_at,
-        conversation_type,
-        source,
-        memory_scope_id,
-        is_auto_title
-      ) VALUES (
-        'conv-upgrade',
-        'Existing conversation',
-        ${now},
-        ${now},
-        'standard',
-        'user',
-        'default',
-        1
-      )
-    `);
-
-    migrateConversationHostAccess(db);
-
-    const row = raw
-      .query(
-        `SELECT id, title, host_access FROM conversations WHERE id = 'conv-upgrade'`,
-      )
-      .get() as {
-      id: string;
-      title: string | null;
-      host_access: number;
-    } | null;
-
-    expect(row).toEqual({
-      id: "conv-upgrade",
-      title: "Existing conversation",
-      host_access: 0,
-    });
-
-    const checkpoint = raw
-      .query(
-        `SELECT value FROM memory_checkpoints WHERE key = 'migration_conversation_host_access_v1'`,
-      )
-      .get() as { value: string } | null;
-    expect(checkpoint?.value).toBe("1");
-  });
-
-  test("re-running the migration preserves existing host access values", () => {
-    const db = createMigrationTestDb();
-    const raw = getSqliteFrom(db);
-    const now = Date.now();
-
-    bootstrapPreHostAccessConversations(raw);
-    raw.exec(/*sql*/ `
-      INSERT INTO conversations (
-        id,
-        title,
-        created_at,
-        updated_at,
-        conversation_type,
-        source,
-        memory_scope_id,
-        is_auto_title
-      ) VALUES (
-        'conv-rerun',
-        'Existing conversation',
-        ${now},
-        ${now},
-        'standard',
-        'user',
-        'default',
-        1
-      )
-    `);
-
-    migrateConversationHostAccess(db);
-    raw.exec(
-      `UPDATE conversations SET host_access = 1 WHERE id = 'conv-rerun'`,
-    );
-
-    expect(() => migrateConversationHostAccess(db)).not.toThrow();
-
-    const row = raw
-      .query(`SELECT host_access FROM conversations WHERE id = 'conv-rerun'`)
-      .get() as { host_access: number } | null;
-    const checkpoint = raw
-      .query(
-        `SELECT value FROM memory_checkpoints WHERE key = 'migration_conversation_host_access_v1'`,
-      )
-      .get() as { value: string } | null;
-
-    expect(row).toEqual({ host_access: 1 });
-    expect(checkpoint?.value).toBe("1");
-  });
 });
 
 // ---------------------------------------------------------------------------
@@ -803,144 +571,3 @@ describe("attachment reuse across conversation lifecycles", () => {
     expect(second.id).not.toBe(first.id);
   });
 });
-
-// ---------------------------------------------------------------------------
-// Baseline: no private-conversation visibility boundary for attachments
-// ---------------------------------------------------------------------------
-
-describe("no private-conversation attachment visibility boundary", () => {
-  beforeEach(() => {
-    const db = getDb();
-    db.run("DELETE FROM message_attachments");
-    db.run("DELETE FROM attachments");
-    db.run("DELETE FROM messages");
-    db.run("DELETE FROM conversations");
-  });
-
-  test("attachment from a private conversation is visible via getAttachmentById (no conversation scoping)", async () => {
-    const privateConv = createConversation({
-      title: "Secret",
-      conversationType: "private",
-    });
-    expect(privateConv.conversationType).toBe("private");
-
-    const msg = await addMessage(
-      privateConv.id,
-      "assistant",
-      "Private content",
-    );
-    const stored = uploadAttachment("secret.pdf", "application/pdf", "JVBER");
-    linkAttachmentToMessage(msg.id, stored.id, 0);
-
-    // Attachment is globally visible by ID — no conversation-type filter exists
-    const fetched = getAttachmentById(stored.id);
-    expect(fetched).not.toBeNull();
-    expect(fetched!.originalFilename).toBe("secret.pdf");
-  });
-
-  test("attachment from a private conversation is copied when linked into a standard conversation", async () => {
-    const privateConv = createConversation({
-      title: "Private",
-      conversationType: "private",
-    });
-    const standardConv = createConversation({
-      title: "Standard",
-      conversationType: "standard",
-    });
-
-    const privateMsg = await addMessage(
-      privateConv.id,
-      "assistant",
-      "Private file",
-    );
-    const standardMsg = await addMessage(
-      standardConv.id,
-      "assistant",
-      "Reusing private file",
-    );
-
-    const stored = uploadAttachment("private-doc.png", "image/png", "PRIVDATA");
-    linkAttachmentToMessage(privateMsg.id, stored.id, 0);
-    linkAttachmentToMessage(standardMsg.id, stored.id, 0);
-
-    // Both conversations can see the attachment
-    const linkedPrivate = getAttachmentsForMessage(privateMsg.id);
-    expect(linkedPrivate).toHaveLength(1);
-
-    const linkedStandard = getAttachmentsForMessage(standardMsg.id);
-    expect(linkedStandard).toHaveLength(1);
-    expect(linkedStandard[0].id).not.toBe(stored.id);
-  });
-
-  test("getAttachmentsForMessage returns private conversation attachments", async () => {
-    const privateConv = createConversation({
-      title: "Private",
-      conversationType: "private",
-    });
-    const msg = await addMessage(privateConv.id, "assistant", "Private media");
-    const stored = uploadAttachment("photo.jpg", "image/jpeg", "AAAA");
-    linkAttachmentToMessage(msg.id, stored.id, 0);
-
-    const linked = getAttachmentsForMessage(msg.id);
-    expect(linked).toHaveLength(1);
-    expect(linked[0].id).toBe(stored.id);
-  });
-
-  test("identical uploads remain distinct across private and standard conversations", () => {
-    createConversation({ title: "Private", conversationType: "private" });
-    createConversation({ title: "Standard", conversationType: "standard" });
-
-    // Same content uploaded in private and standard contexts
-    const fromPrivate = uploadAttachment(
-      "file.png",
-      "image/png",
-      "CROSSCONVERSATION",
-    );
-    const fromStandard = uploadAttachment(
-      "file.png",
-      "image/png",
-      "CROSSCONVERSATION",
-    );
-
-    expect(fromStandard.id).not.toBe(fromPrivate.id);
-  });
-
-  test("clearAll removes attachments from both private and standard conversations", async () => {
-    const privateConv = createConversation({
-      title: "Private",
-      conversationType: "private",
-    });
-    const standardConv = createConversation({
-      title: "Standard",
-      conversationType: "standard",
-    });
-
-    const privateMsg = await addMessage(
-      privateConv.id,
-      "assistant",
-      "Private file",
-    );
-    const standardMsg = await addMessage(
-      standardConv.id,
-      "assistant",
-      "Standard file",
-    );
-
-    const att1 = uploadAttachment("private.png", "image/png", "PRIV");
-    const att2 = uploadAttachment("standard.png", "image/png", "STD");
-    linkAttachmentToMessage(privateMsg.id, att1.id, 0);
-    linkAttachmentToMessage(standardMsg.id, att2.id, 0);
-
-    clearAll();
-
-    const raw = (
-      getDb() as unknown as {
-        $client: import("bun:sqlite").Database;
-      }
-    ).$client;
-    const attachmentCount = raw
-      .query("SELECT COUNT(*) AS c FROM attachments")
-      .get() as { c: number };
-    expect(attachmentCount.c).toBe(0);
-  });
-});

package/src/__tests__/conversation-tool-setup-app-refresh.test.ts

@@ -90,7 +90,7 @@ function makeCtx(overrides: Partial<ToolSetupContext> = {}): ToolSetupContext {
     getQueueDepth: () => 0,
     processMessage: async () => "",
     withSurface: async <T>(_id: string, fn: () => T | Promise<T>) => fn(),
-    memoryPolicy: { scopeId: "default", strictSideEffects: false },
+    memoryPolicy: { scopeId: "default" },
     ...overrides,
   };
 }

package/src/__tests__/conversation-tool-setup-memory-scope.test.ts

@@ -64,7 +64,7 @@ function makeCtx(overrides: Partial<ToolSetupContext> = {}): ToolSetupContext {
     getQueueDepth: () => 0,
     processMessage: async () => "",
     withSurface: async <T>(_id: string, fn: () => T | Promise<T>) => fn(),
-    memoryPolicy: { scopeId: "default", strictSideEffects: false },
+    memoryPolicy: { scopeId: "default" },
     ...overrides,
   };
 }
@@ -106,7 +106,7 @@ const noopLifecycleHandler = mock(() => {});
 describe("session-tool-setup memoryScopeId propagation", () => {
   test("passes default memoryScopeId to executor context", async () => {
     const ctx = makeCtx({
-      memoryPolicy: { scopeId: "default", strictSideEffects: false },
+      memoryPolicy: { scopeId: "default" },
     });
     const { executor, getCaptured } = makeCapturingExecutor();
 
@@ -126,7 +126,7 @@ describe("session-tool-setup memoryScopeId propagation", () => {
 
   test("passes custom memoryScopeId from session memory policy", async () => {
     const ctx = makeCtx({
-      memoryPolicy: { scopeId: "private-thread-abc", strictSideEffects: false },
+      memoryPolicy: { scopeId: "custom-scope-abc" },
     });
     const { executor, getCaptured } = makeCapturingExecutor();
 
@@ -140,12 +140,12 @@ describe("session-tool-setup memoryScopeId propagation", () => {
 
     await toolFn("memory_write", { content: "test" });
 
-    expect(getCaptured()!.memoryScopeId).toBe("private-thread-abc");
+    expect(getCaptured()!.memoryScopeId).toBe("custom-scope-abc");
   });
 
   test("reads memoryScopeId at call time, not construction time", async () => {
     const ctx = makeCtx({
-      memoryPolicy: { scopeId: "initial", strictSideEffects: false },
+      memoryPolicy: { scopeId: "initial" },
     });
     const { executor, getCaptured } = makeCapturingExecutor();
 
@@ -158,7 +158,7 @@ describe("session-tool-setup memoryScopeId propagation", () => {
     );
 
     // Mutate the memory policy after construction
-    ctx.memoryPolicy = { scopeId: "updated-scope", strictSideEffects: false };
+    ctx.memoryPolicy = { scopeId: "updated-scope" };
 
     await toolFn("some_tool", {});
 

package/src/__tests__/conversation-unread-route.test.ts

@@ -49,7 +49,7 @@ describe("POST /v1/conversations/unread", () => {
 
   async function startServer(): Promise<void> {
     port = 20000 + Math.floor(Math.random() * 1000);
-    server = new RuntimeHttpServer({ port, bearerToken: "test-bearer-token" });
+    server = new RuntimeHttpServer({ port });
     await server.start();
   }
 

package/src/__tests__/conversation-usage.test.ts

@@ -39,7 +39,8 @@ mock.module("../memory/conversation-crud.js", () => ({
 }));
 
 import { recordUsage } from "../daemon/conversation-usage.js";
-import { getDb, initializeDb } from "../memory/db.js";
+import { getDb } from "../memory/db-connection.js";
+import { initializeDb } from "../memory/db-init.js";
 import { listUsageEvents } from "../memory/llm-usage-store.js";
 import type { PricingUsage } from "../usage/types.js";
 import { resolvePricingForUsageWithOverrides } from "../util/pricing.js";

package/src/__tests__/conversation-wipe.test.ts

@@ -10,12 +10,12 @@ mock.module("../util/logger.js", () => ({
 import {
   addMessage,
   createConversation,
-  deleteConversation,
   getConversation,
   getMessages,
   wipeConversation,
 } from "../memory/conversation-crud.js";
-import { getDb, initializeDb } from "../memory/db.js";
+import { getDb } from "../memory/db-connection.js";
+import { initializeDb } from "../memory/db-init.js";
 import { enqueueMemoryJob } from "../memory/jobs-store.js";
 
 // Initialize db once before all tests
@@ -139,104 +139,3 @@ describe("wipeConversation", () => {
     expect(result.cancelledJobCount).toBe(0);
   });
 });
-
-describe("deleteConversation — private scope cleanup", () => {
-  beforeEach(() => {
-    const db = getDb();
-    db.run(`DELETE FROM conversation_starters`);
-    db.run(`DELETE FROM memory_graph_nodes`);
-    db.run(`DELETE FROM memory_segments`);
-    db.run(`DELETE FROM memory_summaries`);
-    db.run(`DELETE FROM memory_embeddings`);
-    db.run(`DELETE FROM memory_jobs`);
-    db.run(`DELETE FROM tool_invocations`);
-    db.run(`DELETE FROM llm_request_logs`);
-    db.run(`DELETE FROM messages`);
-    db.run(`DELETE FROM conversations`);
-  });
-
-  test("summaries cleaned up", () => {
-    const conv = createConversation({ conversationType: "private" });
-    const scopeId = conv.memoryScopeId;
-    const now = Date.now();
-
-    const raw = (
-      getDb() as unknown as {
-        $client: import("bun:sqlite").Database;
-      }
-    ).$client;
-
-    // Insert a memory summary with matching scopeId
-    raw
-      .query(
-        `INSERT INTO memory_summaries (id, scope, scope_key, summary, token_estimate, version, scope_id, start_at, end_at, created_at, updated_at)
-         VALUES ('priv-sum-1', 'global', 'all', 'private summary', 100, 1, ?, ?, ?, ?, ?)`,
-      )
-      .run(scopeId, now, now, now, now);
-
-    const result = deleteConversation(conv.id);
-
-    // Summary should be gone
-    const summaryRow = raw
-      .query("SELECT * FROM memory_summaries WHERE id = 'priv-sum-1'")
-      .get();
-    expect(summaryRow).toBeNull();
-
-    // Its ID should be in deletedSummaryIds
-    expect(result.deletedSummaryIds).toContain("priv-sum-1");
-  });
-
-  test("standard conversations unaffected", async () => {
-    // Create a standard conversation and a private one
-    const standardConv = createConversation("standard test");
-    const privateConv = createConversation({ conversationType: "private" });
-
-    // Delete the private conversation
-    deleteConversation(privateConv.id);
-
-    // Standard conversation should still exist
-    expect(getConversation(standardConv.id)).not.toBeNull();
-  });
-
-  test("conversationStarters cleaned up", () => {
-    const conv = createConversation({ conversationType: "private" });
-    const scopeId = conv.memoryScopeId;
-    const now = Date.now();
-
-    const raw = (
-      getDb() as unknown as {
-        $client: import("bun:sqlite").Database;
-      }
-    ).$client;
-
-    // Insert a conversation_starters row with the private scopeId
-    raw
-      .query(
-        `INSERT INTO conversation_starters (id, label, prompt, generation_batch, scope_id, card_type, created_at)
-         VALUES ('starter-1', 'Test starter', 'Tell me about tests', 1, ?, 'chip', ?)`,
-      )
-      .run(scopeId, now);
-
-    // Also insert a default-scope starter that should NOT be deleted
-    raw
-      .query(
-        `INSERT INTO conversation_starters (id, label, prompt, generation_batch, scope_id, card_type, created_at)
-         VALUES ('starter-default', 'Default starter', 'Hello', 1, 'default', 'chip', ?)`,
-      )
-      .run(now);
-
-    deleteConversation(conv.id);
-
-    // Private-scope starter should be gone
-    const starterRow = raw
-      .query("SELECT * FROM conversation_starters WHERE id = 'starter-1'")
-      .get();
-    expect(starterRow).toBeNull();
-
-    // Default-scope starter should still exist
-    const defaultStarterRow = raw
-      .query("SELECT * FROM conversation_starters WHERE id = 'starter-default'")
-      .get();
-    expect(defaultStarterRow).not.toBeNull();
-  });
-});

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

@@ -86,7 +86,6 @@ mock.module("../security/secret-allowlist.js", () => ({
 }));
 
 mock.module("../memory/conversation-crud.js", () => ({
-  getConversationType: () => "default",
   setConversationOriginChannelIfUnset: () => {},
   provenanceFromTrustContext: () => ({
     source: "user",

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

@@ -111,7 +111,6 @@ mock.module("../security/secret-allowlist.js", () => ({
 }));
 
 mock.module("../memory/conversation-crud.js", () => ({
-  getConversationType: () => "default",
   setConversationOriginChannelIfUnset: () => {},
   provenanceFromTrustContext: () => ({
     source: "user",

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

@@ -109,7 +109,6 @@ mock.module("../security/secret-allowlist.js", () => ({
 }));
 
 mock.module("../memory/conversation-crud.js", () => ({
-  getConversationType: () => "default",
   setConversationOriginChannelIfUnset: () => {},
   provenanceFromTrustContext: () => ({
     source: "user",