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

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

@@ -179,6 +179,47 @@ describe("createSchedule (cron)", () => {
     expect(retrieved!.cronExpression).toBe("0 * * * *");
   });
 
+  test("defaults source conversation metadata to null", () => {
+    const job = createSchedule({
+      name: "No source conversation",
+      cronExpression: "0 9 * * *",
+      message: "daily check",
+      syntax: "cron",
+    });
+
+    expect(job.createdFromConversationId).toBeNull();
+    expect(getSchedule(job.id)!.createdFromConversationId).toBeNull();
+
+    const raw = getRawDb()
+      .query("SELECT created_from_conversation_id FROM cron_jobs WHERE id = ?")
+      .get(job.id) as { created_from_conversation_id: string | null };
+    expect(raw.created_from_conversation_id).toBeNull();
+  });
+
+  test("persists source conversation metadata through create, list, and update", () => {
+    const job = createSchedule({
+      name: "With source conversation",
+      cronExpression: "0 9 * * *",
+      message: "daily check",
+      syntax: "cron",
+      createdFromConversationId: "conv-source",
+    });
+
+    expect(job.createdFromConversationId).toBe("conv-source");
+    expect(getSchedule(job.id)!.createdFromConversationId).toBe("conv-source");
+    expect(listSchedules()[0].createdFromConversationId).toBe("conv-source");
+
+    const updated = updateSchedule(job.id, {
+      createdFromConversationId: "conv-updated",
+    });
+    expect(updated!.createdFromConversationId).toBe("conv-updated");
+
+    const cleared = updateSchedule(job.id, {
+      createdFromConversationId: null,
+    });
+    expect(cleared!.createdFromConversationId).toBeNull();
+  });
+
   test("stores schedule_syntax in the DB row", () => {
     const job = createSchedule({
       name: "Syntax check",

package/src/__tests__/schedule-tools.test.ts

@@ -66,6 +66,23 @@ describe("schedule_create tool", () => {
     expect(result.content).toContain("Enabled: true");
   });
 
+  test("persists the creating conversation for recurring schedules", async () => {
+    const result = await executeScheduleCreate(
+      {
+        name: "Recurring source",
+        expression: "0 9 * * *",
+        message: "remember the source",
+      },
+      ctx,
+    );
+
+    expect(result.isError).toBe(false);
+    const row = getRawDb()
+      .query("SELECT created_from_conversation_id FROM cron_jobs LIMIT 1")
+      .get() as { created_from_conversation_id: string | null };
+    expect(row.created_from_conversation_id).toBe(ctx.conversationId);
+  });
+
   test("creates a disabled schedule", async () => {
     const result = await executeScheduleCreate(
       {
@@ -192,6 +209,24 @@ describe("schedule_create with fire_at (one-shot)", () => {
     expect(result.content).toContain("Status: active");
   });
 
+  test("persists the creating conversation for one-shot schedules", async () => {
+    const futureDate = new Date(Date.now() + 24 * 60 * 60 * 1000).toISOString();
+    const result = await executeScheduleCreate(
+      {
+        name: "One-shot source",
+        fire_at: futureDate,
+        message: "remember this source too",
+      },
+      ctx,
+    );
+
+    expect(result.isError).toBe(false);
+    const row = getRawDb()
+      .query("SELECT created_from_conversation_id FROM cron_jobs LIMIT 1")
+      .get() as { created_from_conversation_id: string | null };
+    expect(row.created_from_conversation_id).toBe(ctx.conversationId);
+  });
+
   test("rejects fire_at that is not valid ISO 8601", async () => {
     const result = await executeScheduleCreate(
       {

package/src/__tests__/send-endpoint-busy.test.ts

@@ -91,11 +91,14 @@ mock.module("../config/loader.js", () => ({
 let _conversationFactory: (() => Conversation) | undefined;
 let _approvalGenerator: unknown;
 
-mock.module("../daemon/conversation-store.js", () => ({
+mock.module("../daemon/conversation-registry.js", () => ({
   findConversation: () => {
     if (!_conversationFactory) return undefined;
     return _conversationFactory();
   },
+}));
+
+mock.module("../daemon/conversation-store.js", () => ({
   getOrCreateConversation: async (..._args: unknown[]) => {
     if (!_conversationFactory)
       throw new Error("_conversationFactory not set in test");

package/src/__tests__/server-history-render.test.ts

@@ -8,6 +8,7 @@ mock.module("../util/logger.js", () => ({
 }));
 
 import { renderHistoryContent } from "../daemon/handlers/shared.js";
+import type { ToolActivityMetadata } from "../daemon/message-types/web-activity.js";
 import {
   getAttachmentsForMessage,
   linkAttachmentToMessage,
@@ -226,7 +227,7 @@ describe("renderHistoryContent", () => {
 
     expect(output.text).toBe("");
     expect(output.toolCalls).toEqual([
-      { name: "web_fetch", input: { url: "https://example.com" } },
+      { id: "tu_1", name: "web_fetch", input: { url: "https://example.com" } },
     ]);
     expect(output.toolCallsBeforeText).toBe(true);
   });
@@ -244,6 +245,7 @@ describe("renderHistoryContent", () => {
 
     expect(output.toolCalls).toEqual([
       {
+        id: "tu_1",
         name: "bash",
         input: { command: "ls" },
         result: "file1.txt\nfile2.txt",
@@ -265,6 +267,7 @@ describe("renderHistoryContent", () => {
 
     expect(output.toolCalls).toEqual([
       {
+        id: "tu_1",
         name: "bash",
         input: { command: "bad" },
         result: "command not found",
@@ -273,6 +276,74 @@ describe("renderHistoryContent", () => {
     ]);
   });
 
+  test("omits id when the tool_use block carries none", () => {
+    const output = renderHistoryContent([
+      { type: "tool_use", name: "bash", input: { command: "ls" } },
+    ]);
+
+    // No provider id on the block — emit the entry without an `id` rather than
+    // materializing an empty string, so clients fall back to a synthesized id.
+    expect(output.toolCalls).toEqual([
+      { name: "bash", input: { command: "ls" } },
+    ]);
+    expect(output.toolCalls[0]).not.toHaveProperty("id");
+  });
+
+  test("carries the provider id for server_tool_use blocks", () => {
+    const output = renderHistoryContent([
+      {
+        type: "server_tool_use",
+        id: "srvtu_1",
+        name: "web_search",
+        input: { query: "vellum" },
+      },
+    ]);
+
+    expect(output.toolCalls).toEqual([
+      { id: "srvtu_1", name: "web_search", input: { query: "vellum" } },
+    ]);
+  });
+
+  test("synthesizes a positional id when a tool_use lacks a provider id", () => {
+    const output = renderHistoryContent(
+      [
+        { type: "tool_use", name: "bash", input: { command: "ls" } },
+        { type: "tool_use", name: "bash", input: { command: "pwd" } },
+      ],
+      undefined,
+      "msg-1",
+    );
+
+    // Same positional scheme the web client used to synthesize, so snapshot and
+    // stream tool calls stay keyed consistently and the client can drop its own
+    // fallback once it no longer skews ahead of the daemon.
+    expect(output.toolCalls.map((tc) => tc.id)).toEqual([
+      "tool-history-msg-1-0",
+      "tool-history-msg-1-1",
+    ]);
+  });
+
+  test("keeps the provider id and only synthesizes for blocks missing one", () => {
+    const output = renderHistoryContent(
+      [
+        {
+          type: "tool_use",
+          id: "tu_1",
+          name: "bash",
+          input: { command: "ls" },
+        },
+        { type: "tool_use", name: "bash", input: { command: "pwd" } },
+      ],
+      undefined,
+      "msg-1",
+    );
+
+    expect(output.toolCalls.map((tc) => tc.id)).toEqual([
+      "tu_1",
+      "tool-history-msg-1-1",
+    ]);
+  });
+
   // ── Persisted risk-option ladders (Phase B of conflation track) ─────────────
 
   test("hydrates persisted _risk*Options annotations onto tool calls", () => {
@@ -315,6 +386,79 @@ describe("renderHistoryContent", () => {
     expect(entry.riskDirectoryScopeOptions).toEqual(directoryScopeOptions);
   });
 
+  // ── Persisted tool activity (web_search / web_fetch) ────────────────────────
+
+  test("hydrates persisted _activityMetadata onto a tool_use block", () => {
+    // Mirrors what `annotatePersistedAssistantMessage` writes so the activity
+    // card survives a history reopen instead of degrading to plain text.
+    const activityMetadata: ToolActivityMetadata = {
+      webSearch: {
+        query: "vellum docs",
+        provider: "brave",
+        resultCount: 1,
+        durationMs: 120,
+        results: [
+          {
+            rank: 1,
+            title: "Vellum",
+            url: "https://vellum.ai",
+            domain: "vellum.ai",
+          },
+        ],
+      },
+    };
+
+    const output = renderHistoryContent([
+      {
+        type: "tool_use",
+        id: "tu_1",
+        name: "web_search",
+        input: { query: "vellum docs" },
+        _activityMetadata: activityMetadata,
+      },
+    ]);
+
+    expect(output.toolCalls[0].activityMetadata).toEqual(activityMetadata);
+  });
+
+  test("hydrates persisted _activityMetadata onto a server_tool_use block", () => {
+    const activityMetadata: ToolActivityMetadata = {
+      webSearch: {
+        query: "native search",
+        provider: "anthropic-native",
+        resultCount: 0,
+        durationMs: 80,
+        results: [],
+      },
+    };
+
+    const output = renderHistoryContent([
+      {
+        type: "server_tool_use",
+        id: "srvtu_1",
+        name: "web_search",
+        input: { query: "native search" },
+        _activityMetadata: activityMetadata,
+      },
+    ]);
+
+    expect(output.toolCalls[0].activityMetadata).toEqual(activityMetadata);
+  });
+
+  test("ignores non-object _activityMetadata annotations", () => {
+    const output = renderHistoryContent([
+      {
+        type: "tool_use",
+        id: "tu_1",
+        name: "web_search",
+        input: { query: "x" },
+        _activityMetadata: "not an object",
+      },
+    ]);
+
+    expect(output.toolCalls[0].activityMetadata).toBeUndefined();
+  });
+
   test("ignores non-array _risk*Options annotations", () => {
     // Defensive: a malformed persisted block should not throw or coerce.
     const output = renderHistoryContent([
@@ -355,6 +499,46 @@ describe("renderHistoryContent", () => {
     expect(entry.riskDirectoryScopeOptions).toBeUndefined();
   });
 
+  test("reads back a persisted confirmation decision from the closed enum", () => {
+    // GIVEN a persisted tool_use block stamped with a recorded decision
+    const output = renderHistoryContent([
+      {
+        type: "tool_use",
+        id: "tu_1",
+        name: "bash",
+        input: { command: "rm file" },
+        _confirmationDecision: "denied",
+        _confirmationLabel: "Run Command",
+      },
+    ]);
+
+    // WHEN it is rendered into a history tool call
+    const [entry] = output.toolCalls;
+
+    // THEN the decision survives verbatim alongside its label
+    expect(entry.confirmationDecision).toBe("denied");
+    expect(entry.confirmationLabel).toBe("Run Command");
+  });
+
+  test("drops a _confirmationDecision outside the closed enum", () => {
+    // GIVEN a malformed persisted decision the daemon never writes
+    const output = renderHistoryContent([
+      {
+        type: "tool_use",
+        id: "tu_1",
+        name: "bash",
+        input: { command: "ls" },
+        _confirmationDecision: "bogus",
+      },
+    ]);
+
+    // WHEN it is rendered into a history tool call
+    const [entry] = output.toolCalls;
+
+    // THEN the unknown value is not surfaced on the wire
+    expect(entry.confirmationDecision).toBeUndefined();
+  });
+
   test("handles mixed text and tool blocks", () => {
     const output = renderHistoryContent([
       { type: "text", text: "Let me look that up." },
@@ -569,6 +753,135 @@ describe("renderHistoryContent", () => {
   });
 });
 
+describe("renderHistoryContent contentBlocks", () => {
+  test("builds an ordered block array while walking interleaved content", () => {
+    // GIVEN a turn that interleaves text, reasoning, a tool call, a surface,
+    // and trailing text in the raw model content
+    const output = renderHistoryContent([
+      { type: "text", text: "before tool" },
+      { type: "thinking", thinking: "reasoning", signature: "sig" },
+      { type: "tool_use", id: "t1", name: "run_command", input: { cmd: "ls" } },
+      { type: "tool_result", tool_use_id: "t1", content: "file.txt" },
+      {
+        type: "ui_surface",
+        surfaceId: "s1",
+        surfaceType: "ui_card",
+        data: {},
+      },
+      { type: "text", text: "after tool" },
+    ]);
+
+    // THEN contentBlocks mirrors the walk order
+    expect(output.contentBlocks.map((b) => b.type)).toEqual([
+      "text",
+      "thinking",
+      "tool_use",
+      "surface",
+      "text",
+    ]);
+    expect(output.contentBlocks[0]).toEqual({
+      type: "text",
+      text: "before tool",
+    });
+    expect(output.contentBlocks[1]).toEqual({
+      type: "thinking",
+      thinking: "reasoning",
+    });
+    expect(output.contentBlocks[4]).toEqual({
+      type: "text",
+      text: "after tool",
+    });
+    // AND the tool_use / surface blocks reuse the same objects the positional
+    // arrays hold, so the tool result paired in later is reflected here too
+    const toolBlock = output.contentBlocks[2];
+    expect(toolBlock.type === "tool_use" && toolBlock.toolCall).toBe(
+      output.toolCalls[0],
+    );
+    expect(output.toolCalls[0].result).toBe("file.txt");
+    const surfaceBlock = output.contentBlocks[3];
+    expect(surfaceBlock.type === "surface" && surfaceBlock.surface).toBe(
+      output.surfaces[0],
+    );
+    // AND no attachment block appears (this turn has no file blocks)
+    expect(output.contentBlocks.some((b) => b.type === "attachment")).toBe(
+      false,
+    );
+  });
+
+  const pdfBlock = {
+    type: "file",
+    source: {
+      type: "base64",
+      media_type: "application/pdf",
+      filename: "spec.pdf",
+      data: Buffer.from("hi").toString("base64"),
+    },
+  } as const;
+  const pdfAttachment = {
+    id: "att-1",
+    filename: "spec.pdf",
+    mimeType: "application/pdf",
+    sizeBytes: 2,
+    kind: "file",
+  } as const;
+
+  test("inlines an attachment block when hydrated metadata is supplied", () => {
+    // GIVEN a turn with text, a file attachment, then more text, and the
+    // caller supplies the DB-hydrated metadata for that file block
+    const output = renderHistoryContent(
+      [
+        { type: "text", text: "see file" },
+        pdfBlock,
+        { type: "text", text: "thanks" },
+      ],
+      [pdfAttachment],
+    );
+
+    // THEN the attachment block is placed inline between the two text blocks
+    expect(output.contentBlocks).toEqual([
+      { type: "text", text: "see file" },
+      { type: "attachment", attachment: pdfAttachment },
+      { type: "text", text: "thanks" },
+    ]);
+  });
+
+  test("omits the file block from contentBlocks when no metadata is supplied", () => {
+    // GIVEN the same turn but no hydrated metadata (the file still ships via
+    // the positional attachments array, just not as an inline block)
+    const output = renderHistoryContent([
+      { type: "text", text: "see file" },
+      pdfBlock,
+      { type: "text", text: "thanks" },
+    ]);
+
+    expect(output.contentBlocks).toEqual([
+      { type: "text", text: "see file" },
+      { type: "text", text: "thanks" },
+    ]);
+    expect(output.attachments.length).toBe(1);
+  });
+
+  test("excludes the trailing attachment-description segment from blocks", () => {
+    // GIVEN an attachment-only turn (the legacy text body carries a synthetic
+    // attachment description segment for clients without attachment UI)
+    const output = renderHistoryContent([pdfBlock], [pdfAttachment]);
+
+    // THEN the only block is the inlined attachment — the synthetic text
+    // segment stays in textSegments but never pollutes contentBlocks
+    expect(output.contentBlocks).toEqual([
+      { type: "attachment", attachment: pdfAttachment },
+    ]);
+    expect(output.textSegments.length).toBe(1);
+  });
+
+  test("emits a single text block for the non-array fallback", () => {
+    expect(renderHistoryContent("raw string").contentBlocks).toEqual([
+      { type: "text", text: "raw string" },
+    ]);
+    expect(renderHistoryContent(null).contentBlocks).toEqual([]);
+  });
+});
+
 describe("getAttachmentsForMessage", () => {
   beforeEach(() => {
     const db = getDb();

package/src/__tests__/skill-feature-flags-integration.test.ts

@@ -5,6 +5,8 @@
  * parses it via the real frontmatter parser, and verifies that `skillFlagKey()`
  * returns the correct key and `resolveSkillStates()` correctly gates the skill.
  */
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 
 import { isAssistantFeatureFlagEnabled } from "../config/assistant-feature-flags.js";
@@ -225,3 +227,34 @@ describe("frontmatter feature-flag integration", () => {
     expect(resolvedOff.length).toBe(0);
   });
 });
+
+// ---------------------------------------------------------------------------
+// Bundled ACP skill: discoverability when ACP is disabled
+// ---------------------------------------------------------------------------
+
+describe("bundled acp skill discoverability", () => {
+  test("acp skill resolves with the flag off and config.acp disabled (no frontmatter flag gate)", () => {
+    // The ACP skill carries its own first-time-setup instructions, so it must
+    // stay visible even when the acp flag and config.acp.enabled are both off.
+    // Runtime enforcement happens in the ACP tools via isAcpEnabled instead.
+    const skillMdPath = fileURLToPath(
+      new URL("../config/bundled-skills/acp/SKILL.md", import.meta.url),
+    );
+    const skillMd = readFileSync(skillMdPath, "utf8");
+
+    const skill = buildSkillSummary("acp", skillMd);
+    expect(skill).not.toBeNull();
+    expect(skill!.featureFlag).toBeUndefined();
+    expect(skillFlagKey(skill!)).toBeUndefined();
+
+    // acp flag at its registry default (off) and config.acp disabled.
+    const config = makeConfig({
+      acp: { enabled: false, maxConcurrentSessions: 4, agents: {} },
+    } as Partial<AssistantConfig>);
+
+    const resolved = resolveSkillStates([skill!], config);
+    expect(resolved.length).toBe(1);
+    expect(resolved[0].summary.id).toBe("acp");
+    expect(resolved[0].state).toBe("enabled");
+  });
+});

package/src/__tests__/skillssh-files.test.ts

@@ -384,7 +384,7 @@ describe("toSlimSkill", () => {
     expect(slim!.kind).toBe("catalog");
     expect(slim!.status).toBe("available");
     expect(slim!.origin).toBe("skillssh");
-    expect(slim!.category).toBe("knowledge");
+    expect(slim!.category).toBe("integrations");
     expect((slim as any).slug).toBe("owner/repo/my-skill");
     expect((slim as any).sourceRepo).toBe("owner/repo");
     expect((slim as any).installs).toBe(0);

package/src/__tests__/subagent-call-site-routing.test.ts

@@ -174,7 +174,7 @@ import { LLMSchema } from "../config/schemas/llm.js";
 import {
   clearConversations,
   setConversation,
-} from "../daemon/conversation-store.js";
+} from "../daemon/conversation-registry.js";
 import { CallSiteRoutingProvider } from "../providers/call-site-routing.js";
 import { SubagentManager } from "../subagent/manager.js";
 

package/src/__tests__/subagent-fork-notifications.test.ts

@@ -11,7 +11,7 @@ const capturedNotifications: {
   message: string;
 }[] = [];
 
-mock.module("../daemon/conversation-store.js", () => ({
+mock.module("../daemon/conversation-registry.js", () => ({
   findConversation: (id: string) => ({
     enqueueMessage: (options: { content: string }) => {
       capturedNotifications.push({
@@ -23,8 +23,6 @@ mock.module("../daemon/conversation-store.js", () => ({
     persistUserMessage: async () => ({ id: "mock-msg", deduplicated: false }),
     runAgentLoop: async () => {},
   }),
-  addConversation: () => {},
-  removeConversation: () => {},
 }));
 
 mock.module("../runtime/assistant-event-hub.js", () => ({

package/src/__tests__/subagent-fork-spawn.test.ts

@@ -4,7 +4,7 @@ import {
   clearConversations,
   findConversation,
   setConversation,
-} from "../daemon/conversation-store.js";
+} from "../daemon/conversation-registry.js";
 import type { ServerMessage } from "../daemon/message-protocol.js";
 import type { Message } from "../providers/types.js";
 import { SubagentManager } from "../subagent/manager.js";

package/src/__tests__/subagent-manager-notify.test.ts

@@ -11,7 +11,7 @@ const capturedNotifications: {
   message: string;
 }[] = [];
 
-mock.module("../daemon/conversation-store.js", () => ({
+mock.module("../daemon/conversation-registry.js", () => ({
   findConversation: (id: string) => ({
     enqueueMessage: (options: { content: string }) => {
       capturedNotifications.push({
@@ -23,8 +23,6 @@ mock.module("../daemon/conversation-store.js", () => ({
     persistUserMessage: async () => ({ id: "mock-msg", deduplicated: false }),
     runAgentLoop: async () => {},
   }),
-  addConversation: () => {},
-  removeConversation: () => {},
 }));
 
 mock.module("../runtime/assistant-event-hub.js", () => ({

package/src/__tests__/subagent-notify-parent.test.ts

@@ -36,7 +36,7 @@ mock.module("../memory/conversation-crud.js", () => ({
  */
 const capturedMessages: string[] = [];
 
-mock.module("../daemon/conversation-store.js", () => ({
+mock.module("../daemon/conversation-registry.js", () => ({
   findConversation: (_id: string) => ({
     enqueueMessage: (options: { content: string }) => {
       capturedMessages.push(options.content);
@@ -45,8 +45,6 @@ mock.module("../daemon/conversation-store.js", () => ({
     persistUserMessage: async () => ({ id: "mock-msg", deduplicated: false }),
     runAgentLoop: async () => {},
   }),
-  addConversation: () => {},
-  removeConversation: () => {},
 }));
 
 mock.module("../runtime/assistant-event-hub.js", () => ({

package/src/__tests__/subagent-spawn-tool-fork.test.ts

@@ -32,7 +32,7 @@ mock.module("../memory/conversation-crud.js", () => ({
 import {
   clearConversations,
   setConversation,
-} from "../daemon/conversation-store.js";
+} from "../daemon/conversation-registry.js";
 import type { Message } from "../providers/types.js";
 import { getSubagentManager } from "../subagent/index.js";
 import { executeSubagentSpawn } from "../tools/subagent/spawn.js";

package/src/__tests__/system-prompt.test.ts

@@ -673,6 +673,26 @@ describe("buildSystemPrompt", () => {
       expect(result).toContain("Batch independent tool calls");
     });
 
+    test("bundled communication section renders and sorts before the parallel-tool-calls block", () => {
+      // `01-communication` sorts ahead of `01-parallel-tool-calls`, so the
+      // communication guidance leads the operational sections.
+      const result = buildSystemPrompt();
+      expect(result).toContain("## Communication");
+      // The core rule: deliberation belongs in private thinking, not text.
+      expect(result).toContain(
+        "in your private thinking — never in user-facing text",
+      );
+      // Closes by deferring to the user's established communication preferences.
+      expect(result).toContain(
+        "Always prioritize communication preferences that you've established",
+      );
+      const communicationIdx = result.indexOf("## Communication");
+      const parallelIdx = result.indexOf("<use_parallel_tool_calls>");
+      expect(communicationIdx).toBeGreaterThan(-1);
+      expect(parallelIdx).toBeGreaterThan(-1);
+      expect(communicationIdx).toBeLessThan(parallelIdx);
+    });
+
     test("workspace prefix with frontmatter renders body at the very top", () => {
       mkdirSync(SYSTEM_PROMPTS_DIR, { recursive: true });
       writeFileSync(