@vellumai/assistant 0.5.1 → 0.5.3

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

@@ -1,6 +1,10 @@
+import { mkdirSync, mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
 import type { AgentEvent } from "../agent/loop.js";
+import { getConversationDirName } from "../memory/conversation-disk-view.js";
 import type { Message, ProviderResponse } from "../providers/types.js";
 
 // ---------------------------------------------------------------------------
@@ -79,6 +83,7 @@ mock.module("../memory/conversation-crud.js", () => ({
   getMessages: () => [],
   getConversation: () => ({
     id: "conv-1",
+    createdAt: Date.parse("2026-03-19T12:00:00.000Z"),
     contextSummary: null,
     contextCompactedMessageCount: 0,
     contextCompactedAt: null,
@@ -175,7 +180,7 @@ import { Conversation } from "../daemon/conversation.js";
 // Helpers
 // ---------------------------------------------------------------------------
 
-function makeConversation(): Conversation {
+function makeConversation(workingDir = "/tmp"): Conversation {
   const provider = {
     name: "mock",
     async sendMessage(): Promise<ProviderResponse> {
@@ -193,10 +198,17 @@ function makeConversation(): Conversation {
     "system prompt",
     4096,
     () => {},
-    "/tmp",
+    workingDir,
   );
 }
 
+const conversationDirName = getConversationDirName(
+  "conv-1",
+  Date.parse("2026-03-19T12:00:00.000Z"),
+);
+const conversationPath = `conversations/${conversationDirName}/`;
+const conversationAttachmentsPath = `${conversationPath}attachments/`;
+
 // ---------------------------------------------------------------------------
 // Tests
 // ---------------------------------------------------------------------------
@@ -224,6 +236,12 @@ describe("Conversation workspace cache state", () => {
     expect(conversation.getWorkspaceTopLevelContext()!).toContain(
       "</workspace_top_level>",
     );
+    expect(conversation.getWorkspaceTopLevelContext()!).toContain(
+      `Current conversation folder: ${conversationPath}`,
+    );
+    expect(conversation.getWorkspaceTopLevelContext()!).toContain(
+      `Attachment files: ${conversationAttachmentsPath}`,
+    );
   });
 
   test("refreshWorkspaceTopLevelContextIfNeeded no-ops when not dirty and cache exists", () => {
@@ -257,4 +275,28 @@ describe("Conversation workspace cache state", () => {
     );
     expect(conversation.isWorkspaceTopLevelDirty()).toBe(false);
   });
+
+  test("workspace hints follow the resolved legacy directory when canonical is absent", () => {
+    const workspaceRoot = mkdtempSync(
+      join(tmpdir(), "conversation-workspace-cache-state-"),
+    );
+    const legacyDirName = `conv-1_2026-03-19T12-00-00.000Z`;
+    mkdirSync(join(workspaceRoot, "conversations", legacyDirName), {
+      recursive: true,
+    });
+
+    try {
+      const tempConversation = makeConversation(workspaceRoot);
+      tempConversation.refreshWorkspaceTopLevelContextIfNeeded();
+
+      expect(tempConversation.getWorkspaceTopLevelContext()!).toContain(
+        `Current conversation folder: conversations/${legacyDirName}/`,
+      );
+      expect(tempConversation.getWorkspaceTopLevelContext()!).toContain(
+        `Attachment files: conversations/${legacyDirName}/attachments/`,
+      );
+    } finally {
+      rmSync(workspaceRoot, { recursive: true, force: true });
+    }
+  });
 });

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

@@ -1,6 +1,7 @@
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
 import type { AgentEvent } from "../agent/loop.js";
+import { getConversationDirName } from "../memory/conversation-disk-view.js";
 import type { Message, ProviderResponse } from "../providers/types.js";
 
 // ---------------------------------------------------------------------------
@@ -115,6 +116,7 @@ mock.module("../memory/conversation-crud.js", () => ({
   getMessages: () => [],
   getConversation: () => ({
     id: "conv-1",
+    createdAt: Date.parse("2026-03-19T12:00:00.000Z"),
     contextSummary: null,
     contextCompactedMessageCount: 0,
     contextCompactedAt: null,
@@ -277,6 +279,13 @@ function messageText(message: Message): string {
     .join("\n");
 }
 
+const conversationDirName = getConversationDirName(
+  "conv-1",
+  Date.parse("2026-03-19T12:00:00.000Z"),
+);
+const conversationPath = `conversations/${conversationDirName}/`;
+const conversationAttachmentsPath = `${conversationPath}attachments/`;
+
 // ---------------------------------------------------------------------------
 // Tests
 // ---------------------------------------------------------------------------
@@ -312,6 +321,8 @@ describe("Conversation workspace injection", () => {
     const runtimeUser = runCalls[0][runCalls[0].length - 1];
     const text = messageText(runtimeUser);
     expect(text).toContain("Root: /tmp");
+    expect(text).toContain(`Current conversation folder: ${conversationPath}`);
+    expect(text).toContain(`Attachment files: ${conversationAttachmentsPath}`);
   });
 
   test("workspace context is prepended before user text", async () => {

package/src/__tests__/credential-security-invariants.test.ts

@@ -251,6 +251,9 @@ describe("Invariant 2: no generic plaintext secret read API", () => {
       "tools/claude-code/claude-code.ts", // Claude Code tool API key lookup
       "workspace/migrations/006-services-config.ts", // services config migration reads provider API keys
       "cli/commands/avatar.ts", // CLI avatar generation API key lookup
+      "config/bundled-skills/slack/tools/shared.ts", // Slack skill bot token lookup
+      "daemon/conversation-process.ts", // masked provider key display
+      "daemon/handlers/config-model.ts", // masked provider key display
     ]);
 
     const thisDir = dirname(fileURLToPath(import.meta.url));

package/src/__tests__/credential-vault-unit.test.ts

@@ -102,13 +102,10 @@ mock.module("../daemon/handlers/config-slack-channel.js", () => ({
     slackChannelConfigCalls.push({ botToken, appToken });
 
     const { credentialKey } = await import("../security/credential-key.js");
-    const {
-      getSecureKeyAsync,
-      setSecureKeyAsync,
-    } = await import("../security/secure-keys.js");
-    const { upsertCredentialMetadata } = await import(
-      "../tools/credentials/metadata-store.js"
-    );
+    const { getSecureKeyAsync, setSecureKeyAsync } =
+      await import("../security/secure-keys.js");
+    const { upsertCredentialMetadata } =
+      await import("../tools/credentials/metadata-store.js");
 
     const hasExistingBotToken = !!(await getSecureKeyAsync(
       credentialKey("slack_channel", "bot_token"),
@@ -646,9 +643,7 @@ describe("credential_store tool — prompt action", () => {
     );
     expect(appResult.isError).toBe(false);
     expect(manualConnectionStore["slack_channel"]).toBeUndefined();
-    expect(slackChannelConfigCalls).toEqual([
-      { appToken: "xapp-test-token" },
-    ]);
+    expect(slackChannelConfigCalls).toEqual([{ appToken: "xapp-test-token" }]);
     expect(appResult.content).toContain("connection incomplete");
 
     const botResult = await credentialStoreTool.execute(

package/src/__tests__/cu-unified-flow.test.ts

@@ -30,6 +30,7 @@ function buildMockContext(
     lastSurfaceAction: new Map(),
     surfaceState: new Map(),
     surfaceUndoStacks: new Map(),
+    accumulatedSurfaceState: new Map(),
     surfaceActionRequestIds: new Set(),
     currentTurnSurfaces: [],
     hostCuProxy,

package/src/__tests__/db-conversation-fork-lineage-migration.test.ts

@@ -0,0 +1,241 @@
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { Database } from "bun:sqlite";
+import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
+
+import { drizzle } from "drizzle-orm/bun-sqlite";
+
+const testDir = mkdtempSync(join(tmpdir(), "conversation-fork-lineage-"));
+const dbPath = join(testDir, "test.db");
+const originalBunTest = process.env.BUN_TEST;
+
+mock.module("../util/platform.js", () => ({
+  getDataDir: () => testDir,
+  isMacOS: () => process.platform === "darwin",
+  isLinux: () => process.platform === "linux",
+  isWindows: () => process.platform === "win32",
+  getPidPath: () => join(testDir, "test.pid"),
+  getDbPath: () => dbPath,
+  getLogPath: () => join(testDir, "test.log"),
+  ensureDataDir: () => {},
+}));
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+import { initializeDb, resetDb } from "../memory/db.js";
+import { getSqliteFrom } from "../memory/db-connection.js";
+import { migrateConversationForkLineage } from "../memory/migrations/183-add-conversation-fork-lineage.js";
+import * as schema from "../memory/schema.js";
+
+function createTestDb() {
+  const sqlite = new Database(":memory:");
+  sqlite.exec("PRAGMA journal_mode=WAL");
+  sqlite.exec("PRAGMA foreign_keys = ON");
+  return drizzle(sqlite, { schema });
+}
+
+function getColumnNames(raw: Database): string[] {
+  return (
+    raw.query(`PRAGMA table_info(conversations)`).all() as Array<{ name: string }>
+  ).map((column) => column.name);
+}
+
+function hasIndex(raw: Database, indexName: string): boolean {
+  const row = raw
+    .query(`SELECT 1 FROM sqlite_master WHERE type = 'index' AND name = ?`)
+    .get(indexName);
+  return row != null;
+}
+
+function bootstrapPreLineageConversations(raw: Database): void {
+  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,
+      is_auto_title INTEGER NOT NULL DEFAULT 1,
+      schedule_job_id TEXT
+    )
+  `);
+}
+
+function removeTestDbFiles(): void {
+  resetDb();
+  rmSync(dbPath, { force: true });
+  rmSync(`${dbPath}-shm`, { force: true });
+  rmSync(`${dbPath}-wal`, { force: true });
+}
+
+describe("conversation fork lineage migration", () => {
+  beforeEach(() => {
+    process.env.BUN_TEST = "0";
+    removeTestDbFiles();
+  });
+
+  afterAll(() => {
+    process.env.BUN_TEST = originalBunTest;
+    removeTestDbFiles();
+    try {
+      rmSync(testDir, { recursive: true });
+    } catch {
+      /* best effort */
+    }
+  });
+
+  test("fresh DB initialization includes nullable lineage columns and parent lookup index", () => {
+    initializeDb();
+
+    const raw = new Database(dbPath);
+    const columns = getColumnNames(raw);
+
+    expect(columns).toContain("fork_parent_conversation_id");
+    expect(columns).toContain("fork_parent_message_id");
+    expect(hasIndex(raw, "idx_conversations_fork_parent_conversation_id")).toBe(
+      true,
+    );
+
+    const forkColumns = (
+      raw.query(`PRAGMA table_info(conversations)`).all() as Array<{
+        name: string;
+        notnull: number;
+      }>
+    ).filter(
+      (column) =>
+        column.name === "fork_parent_conversation_id" ||
+        column.name === "fork_parent_message_id",
+    );
+
+    expect(forkColumns).toHaveLength(2);
+    expect(forkColumns.every((column) => column.notnull === 0)).toBe(true);
+    raw.close();
+  });
+
+  test("migration upgrades the previous schema without disturbing existing conversation rows", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+    const now = Date.now();
+
+    bootstrapPreLineageConversations(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
+      )
+    `);
+
+    migrateConversationForkLineage(db);
+
+    expect(getColumnNames(raw)).toContain("fork_parent_conversation_id");
+    expect(getColumnNames(raw)).toContain("fork_parent_message_id");
+    expect(hasIndex(raw, "idx_conversations_fork_parent_conversation_id")).toBe(
+      true,
+    );
+
+    const row = raw
+      .query(
+        `SELECT id, title, fork_parent_conversation_id, fork_parent_message_id FROM conversations WHERE id = 'conv-upgrade'`,
+      )
+      .get() as {
+      id: string;
+      title: string | null;
+      fork_parent_conversation_id: string | null;
+      fork_parent_message_id: string | null;
+    } | null;
+
+    expect(row).toEqual({
+      id: "conv-upgrade",
+      title: "Existing conversation",
+      fork_parent_conversation_id: null,
+      fork_parent_message_id: null,
+    });
+  });
+
+  test("re-running the migration preserves existing lineage data", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+    const now = Date.now();
+
+    bootstrapPreLineageConversations(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',
+        'Forked conversation',
+        ${now},
+        ${now},
+        'standard',
+        'user',
+        'default',
+        1
+      )
+    `);
+
+    migrateConversationForkLineage(db);
+    raw.exec(/*sql*/ `
+      UPDATE conversations
+      SET fork_parent_conversation_id = 'conv-parent',
+          fork_parent_message_id = 'msg-parent'
+      WHERE id = 'conv-rerun'
+    `);
+
+    expect(() => migrateConversationForkLineage(db)).not.toThrow();
+
+    const row = raw
+      .query(
+        `SELECT fork_parent_conversation_id, fork_parent_message_id FROM conversations WHERE id = 'conv-rerun'`,
+      )
+      .get() as {
+      fork_parent_conversation_id: string | null;
+      fork_parent_message_id: string | null;
+    } | null;
+
+    expect(row).toEqual({
+      fork_parent_conversation_id: "conv-parent",
+      fork_parent_message_id: "msg-parent",
+    });
+    expect(hasIndex(raw, "idx_conversations_fork_parent_conversation_id")).toBe(
+      true,
+    );
+  });
+});

package/src/__tests__/db-llm-request-log-provider-migration.test.ts

@@ -0,0 +1,214 @@
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { Database } from "bun:sqlite";
+import { afterAll, afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+
+import { drizzle } from "drizzle-orm/bun-sqlite";
+
+const testDir = mkdtempSync(join(tmpdir(), "llm-request-log-provider-"));
+const dbPath = join(testDir, "test.db");
+const originalBunTest = process.env.BUN_TEST;
+
+mock.module("../util/platform.js", () => ({
+  getDataDir: () => testDir,
+  isMacOS: () => process.platform === "darwin",
+  isLinux: () => process.platform === "linux",
+  isWindows: () => process.platform === "win32",
+  getPidPath: () => join(testDir, "test.pid"),
+  getDbPath: () => dbPath,
+  getLogPath: () => join(testDir, "test.log"),
+  ensureDataDir: () => {},
+}));
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+import { initializeDb, resetDb } from "../memory/db.js";
+import { getSqliteFrom } from "../memory/db-connection.js";
+import { migrateLlmRequestLogProvider } from "../memory/migrations/184-llm-request-log-provider.js";
+import * as schema from "../memory/schema.js";
+
+function createTestDb() {
+  const sqlite = new Database(":memory:");
+  sqlite.exec("PRAGMA journal_mode=WAL");
+  sqlite.exec("PRAGMA foreign_keys = ON");
+  return drizzle(sqlite, { schema });
+}
+
+function getColumnInfo(raw: Database): Array<{ name: string; notnull: number }> {
+  return raw.query(`PRAGMA table_info(llm_request_logs)`).all() as Array<{
+    name: string;
+    notnull: number;
+  }>;
+}
+
+function bootstrapPreProviderLlmRequestLogs(raw: Database): void {
+  raw.exec(/*sql*/ `
+    CREATE TABLE llm_request_logs (
+      id TEXT PRIMARY KEY,
+      conversation_id TEXT NOT NULL,
+      message_id TEXT,
+      request_payload TEXT NOT NULL,
+      response_payload TEXT NOT NULL,
+      created_at INTEGER NOT NULL
+    )
+  `);
+}
+
+function removeTestDbFiles(): void {
+  rmSync(dbPath, { force: true });
+  rmSync(`${dbPath}-shm`, { force: true });
+  rmSync(`${dbPath}-wal`, { force: true });
+}
+
+describe("llm_request_logs provider migration", () => {
+  beforeEach(() => {
+    process.env.BUN_TEST = "0";
+    resetDb();
+    removeTestDbFiles();
+  });
+
+  afterEach(() => {
+    resetDb();
+    removeTestDbFiles();
+  });
+
+  afterAll(() => {
+    if (originalBunTest === undefined) {
+      delete process.env.BUN_TEST;
+    } else {
+      process.env.BUN_TEST = originalBunTest;
+    }
+    resetDb();
+    removeTestDbFiles();
+    try {
+      rmSync(testDir, { recursive: true });
+    } catch {
+      /* best effort */
+    }
+  });
+
+  test("fresh DB initialization includes llm_request_logs.provider", () => {
+    initializeDb();
+
+    const raw = new Database(dbPath);
+    const columns = getColumnInfo(raw);
+
+    expect(columns.some((column) => column.name === "provider")).toBe(true);
+    expect(columns.find((column) => column.name === "provider")?.notnull).toBe(
+      0,
+    );
+
+    raw.close();
+  });
+
+  test("migration upgrades the pre-provider schema without disturbing rows", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+
+    bootstrapPreProviderLlmRequestLogs(raw);
+    raw.exec(/*sql*/ `
+      INSERT INTO llm_request_logs (
+        id,
+        conversation_id,
+        message_id,
+        request_payload,
+        response_payload,
+        created_at
+      ) VALUES (
+        'log-upgrade',
+        'conv-1',
+        'msg-1',
+        '{}',
+        '{"ok":true}',
+        1000
+      )
+    `);
+
+    migrateLlmRequestLogProvider(db);
+
+    expect(getColumnInfo(raw).some((column) => column.name === "provider")).toBe(
+      true,
+    );
+
+    const row = raw
+      .query(
+        `SELECT id, conversation_id, message_id, provider, request_payload, response_payload, created_at
+         FROM llm_request_logs
+         WHERE id = 'log-upgrade'`,
+      )
+      .get() as
+      | {
+          id: string;
+          conversation_id: string;
+          message_id: string | null;
+          provider: string | null;
+          request_payload: string;
+          response_payload: string;
+          created_at: number;
+        }
+      | null;
+
+    expect(row).toEqual({
+      id: "log-upgrade",
+      conversation_id: "conv-1",
+      message_id: "msg-1",
+      provider: null,
+      request_payload: "{}",
+      response_payload: '{"ok":true}',
+      created_at: 1000,
+    });
+
+    raw.close();
+  });
+
+  test("re-running the migration preserves populated provider values", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+
+    bootstrapPreProviderLlmRequestLogs(raw);
+    raw.exec(/*sql*/ `
+      INSERT INTO llm_request_logs (
+        id,
+        conversation_id,
+        message_id,
+        request_payload,
+        response_payload,
+        created_at
+      ) VALUES (
+        'log-rerun',
+        'conv-2',
+        'msg-2',
+        '{}',
+        '{"ok":true}',
+        2000
+      )
+    `);
+
+    migrateLlmRequestLogProvider(db);
+    raw.exec(/*sql*/ `
+      UPDATE llm_request_logs
+      SET provider = 'anthropic'
+      WHERE id = 'log-rerun'
+    `);
+
+    expect(() => migrateLlmRequestLogProvider(db)).not.toThrow();
+
+    const row = raw
+      .query(
+        `SELECT provider FROM llm_request_logs WHERE id = 'log-rerun'`,
+      )
+      .get() as { provider: string | null } | null;
+
+    expect(row).toEqual({
+      provider: "anthropic",
+    });
+
+    raw.close();
+  });
+});