@vellumai/assistant 0.8.2 → 0.8.4

package/src/__tests__/conversation-clean-command.test.ts

@@ -0,0 +1,137 @@
+/**
+ * Tests for the `/clean` slash command primitives.
+ *
+ * `/clean` is wired up so that:
+ *   1. Runtime injection prefixes are stripped from user-message text blocks
+ *      (same allowlist `/compact` uses).
+ *   2. Assistant turns, tool_use blocks, and tool_result blocks are preserved
+ *      verbatim — `/clean` never alters history shape.
+ *   3. The user-facing result message reports tokens reclaimed and the
+ *      number of messages preserved.
+ *
+ * The slash-routing layer is covered by `conversation-slash-commands.test.ts`;
+ * the graph-memory eviction hook is covered by the v2 routing tests. This
+ * file focuses on the formatter and the strip behavior that defines the
+ * "no history loss" contract.
+ */
+import { describe, expect, test } from "bun:test";
+
+import { formatCleanResult } from "../daemon/conversation-process.js";
+import { stripInjectionsForCompaction } from "../daemon/conversation-runtime-assembly.js";
+import type { Message } from "../providers/types.js";
+
+describe("formatCleanResult", () => {
+  test("formats token reclamation and preserved-message count", () => {
+    const out = formatCleanResult({
+      previousEstimatedInputTokens: 100_000,
+      estimatedInputTokens: 95_000,
+      maxInputTokens: 200_000,
+      preservedMessages: 250,
+    });
+    expect(out).toContain("Context Cleaned");
+    expect(out).toContain("100,000 → 95,000 (5,000 reclaimed)");
+    expect(out).toContain("95,000 / 200,000 tokens");
+    expect(out).toContain("250 preserved");
+  });
+
+  test("renders zero reclaimed when nothing was stripped", () => {
+    const out = formatCleanResult({
+      previousEstimatedInputTokens: 12_345,
+      estimatedInputTokens: 12_345,
+      maxInputTokens: 200_000,
+      preservedMessages: 10,
+    });
+    expect(out).toContain("12,345 → 12,345 (0 reclaimed)");
+    expect(out).toContain("10 preserved");
+  });
+});
+
+describe("stripInjectionsForCompaction preserves history shape", () => {
+  test("strips known injection prefixes from user text blocks", () => {
+    const messages: Message[] = [
+      {
+        role: "user",
+        content: [
+          {
+            type: "text",
+            text: "<NOW.md Always keep this up to date>\nfoo\n</NOW.md>",
+          },
+          { type: "text", text: "Hello, please help with X." },
+        ],
+      },
+    ];
+    const out = stripInjectionsForCompaction(messages);
+    expect(out).toHaveLength(1);
+    expect(out[0].content).toHaveLength(1);
+    expect(out[0].content[0]).toEqual({
+      type: "text",
+      text: "Hello, please help with X.",
+    });
+  });
+
+  test("preserves assistant turns and tool_use/tool_result blocks verbatim", () => {
+    const messages: Message[] = [
+      {
+        role: "user",
+        content: [
+          {
+            type: "text",
+            text: "<knowledge_base>\nstale kb\n</knowledge_base>",
+          },
+          { type: "text", text: "Run the calculator." },
+        ],
+      },
+      {
+        role: "assistant",
+        content: [
+          { type: "text", text: "Using the calculator." },
+          {
+            type: "tool_use",
+            id: "tool-1",
+            name: "calculator",
+            input: { expr: "1 + 2" },
+          },
+        ],
+      },
+      {
+        role: "user",
+        content: [
+          {
+            type: "tool_result",
+            tool_use_id: "tool-1",
+            content: "3",
+          },
+        ],
+      },
+      {
+        role: "assistant",
+        content: [{ type: "text", text: "The answer is 3." }],
+      },
+    ];
+
+    const out = stripInjectionsForCompaction(messages);
+
+    expect(out).toHaveLength(4);
+    expect(out[0].content).toEqual([
+      { type: "text", text: "Run the calculator." },
+    ]);
+    expect(out[1]).toEqual(messages[1]);
+    expect(out[2]).toEqual(messages[2]);
+    expect(out[3]).toEqual(messages[3]);
+  });
+
+  test("leaves <turn_context>, <workspace>, and <memory __injected> alone", () => {
+    const messages: Message[] = [
+      {
+        role: "user",
+        content: [
+          { type: "text", text: "<turn_context>\nnow\n</turn_context>" },
+          { type: "text", text: "<workspace>\nfiles\n</workspace>" },
+          { type: "text", text: "<memory __injected>\nrecent\n</memory>" },
+        ],
+      },
+    ];
+    const out = stripInjectionsForCompaction(messages);
+    expect(out[0].content).toEqual(messages[0].content);
+  });
+});

package/src/__tests__/conversation-confirmation-signals.test.ts

@@ -51,7 +51,7 @@ mock.module("../memory/guardian-action-store.js", () => ({
 
 mock.module("../providers/registry.js", () => ({
   getProvider: () => ({ name: "mock-provider" }),
-  initializeProviders: () => {},
+  initializeProviders: async () => {},
 }));
 
 mock.module("../config/loader.js", () => ({

package/src/__tests__/conversation-fork-crud.test.ts

@@ -49,6 +49,7 @@ import {
   getRetrospectiveState,
   upsertRetrospectiveState,
 } from "../memory/memory-retrospective-state.js";
+import { rawGet, rawRun } from "../memory/raw-query.js";
 import {
   activationState,
   channelInboundEvents,
@@ -296,6 +297,114 @@ describe("forkConversation", () => {
     ]);
   });
 
+  test("inherits cleanedAt when forking past the clean event", async () => {
+    const source = createConversation("Clean thread");
+    await addMessage(source.id, "user", "Message 1", undefined, {
+      skipIndexing: true,
+    });
+    const preClean = await addMessage(
+      source.id,
+      "assistant",
+      "Message 2",
+      undefined,
+      { skipIndexing: true },
+    );
+
+    const cleanedAt = preClean.createdAt + 1;
+    getDb()
+      .update(conversations)
+      .set({ cleanedAt })
+      .where(eq(conversations.id, source.id))
+      .run();
+
+    const postClean = await addMessage(
+      source.id,
+      "user",
+      "Message 3",
+      undefined,
+      { skipIndexing: true },
+    );
+    expect(postClean.createdAt).toBeGreaterThanOrEqual(cleanedAt);
+
+    const fork = forkConversation({
+      conversationId: source.id,
+      throughMessageId: postClean.id,
+    });
+
+    expect(fork.cleanedAt).toBe(cleanedAt);
+  });
+
+  test("does not inherit cleanedAt when forking before the clean event", async () => {
+    const source = createConversation("Clean thread");
+    await addMessage(source.id, "user", "Message 1", undefined, {
+      skipIndexing: true,
+    });
+    const preClean = await addMessage(
+      source.id,
+      "assistant",
+      "Message 2",
+      undefined,
+      { skipIndexing: true },
+    );
+
+    const cleanedAt = preClean.createdAt + 1;
+    getDb()
+      .update(conversations)
+      .set({ cleanedAt })
+      .where(eq(conversations.id, source.id))
+      .run();
+
+    await addMessage(source.id, "user", "Message 3", undefined, {
+      skipIndexing: true,
+    });
+
+    const fork = forkConversation({
+      conversationId: source.id,
+      throughMessageId: preClean.id,
+    });
+
+    expect(fork.cleanedAt).toBeNull();
+  });
+
+  test("inherits cleanedAt on a full-history fork", async () => {
+    const source = createConversation("Clean thread");
+    await addMessage(source.id, "user", "Message 1", undefined, {
+      skipIndexing: true,
+    });
+    const last = await addMessage(
+      source.id,
+      "assistant",
+      "Message 2",
+      undefined,
+      { skipIndexing: true },
+    );
+
+    const cleanedAt = last.createdAt - 1;
+    getDb()
+      .update(conversations)
+      .set({ cleanedAt })
+      .where(eq(conversations.id, source.id))
+      .run();
+
+    const fork = forkConversation({ conversationId: source.id });
+
+    expect(fork.cleanedAt).toBe(cleanedAt);
+  });
+
+  test("leaves cleanedAt null when the source has no clean event", async () => {
+    const source = createConversation("Unclean thread");
+    await addMessage(source.id, "user", "Message 1", undefined, {
+      skipIndexing: true,
+    });
+    await addMessage(source.id, "assistant", "Message 2", undefined, {
+      skipIndexing: true,
+    });
+
+    const fork = forkConversation({ conversationId: source.id });
+
+    expect(fork.cleanedAt).toBeNull();
+  });
+
   test("rejects forks when the source conversation has no persisted messages", () => {
     const source = createConversation("Empty thread");
 
@@ -661,6 +770,58 @@ describe("forkConversation", () => {
     expect(loadGraphMemoryState(fork.id)).toBeNull();
   });
 
+  test("defaults conversationType to standard and inherits the parent's group", async () => {
+    const source = createConversation("Default inheritance thread");
+    await addMessage(source.id, "user", "first message", undefined, {
+      skipIndexing: true,
+    });
+    rawRun(
+      "UPDATE conversations SET group_id = ? WHERE id = ?",
+      "system:pinned",
+      source.id,
+    );
+
+    const fork = forkConversation({ conversationId: source.id });
+    const row = getDb()
+      .select()
+      .from(conversations)
+      .where(eq(conversations.id, fork.id))
+      .get();
+    const groupIdRow = rawGet<{ group_id: string | null }>(
+      "SELECT group_id FROM conversations WHERE id = ?",
+      fork.id,
+    );
+
+    expect(row?.conversationType).toBe("standard");
+    expect(groupIdRow?.group_id).toBe("system:pinned");
+  });
+
+  test("honors conversationType and groupId overrides on the fork", async () => {
+    const source = createConversation("Override thread");
+    await addMessage(source.id, "user", "first message", undefined, {
+      skipIndexing: true,
+    });
+
+    const fork = forkConversation({
+      conversationId: source.id,
+      conversationType: "background",
+      groupId: "system:background",
+    });
+
+    const row = getDb()
+      .select()
+      .from(conversations)
+      .where(eq(conversations.id, fork.id))
+      .get();
+    const groupIdRow = rawGet<{ group_id: string | null }>(
+      "SELECT group_id FROM conversations WHERE id = ?",
+      fork.id,
+    );
+
+    expect(row?.conversationType).toBe("background");
+    expect(groupIdRow?.group_id).toBe("system:background");
+  });
+
   test("copies memory state when throughMessageId points at the last message", async () => {
     const source = createConversation("Through-last thread");
     const lastMessage = await addMessage(

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

@@ -8,7 +8,7 @@ mock.module("../util/logger.js", () => ({
 
 mock.module("../providers/registry.js", () => ({
   getProvider: () => ({ name: "mock-provider" }),
-  initializeProviders: () => {},
+  initializeProviders: async () => {},
 }));
 
 mock.module("../config/loader.js", () => ({

package/src/__tests__/conversation-load-cleaned-at.test.ts

@@ -0,0 +1,279 @@
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, { get: () => () => {} }),
+}));
+
+mock.module("../providers/registry.js", () => ({
+  getProvider: () => ({ name: "mock-provider" }),
+  initializeProviders: async () => {},
+}));
+
+mock.module("../config/loader.js", () => ({
+  getConfig: () => ({
+    ui: {},
+    llm: {
+      default: {
+        provider: "mock-provider",
+        model: "mock-model",
+        maxTokens: 4096,
+        effort: "max" as const,
+        speed: "standard" as const,
+        temperature: null,
+        thinking: { enabled: false, streamThinking: true },
+        contextWindow: {
+          enabled: true,
+          maxInputTokens: 100000,
+          targetBudgetRatio: 0.3,
+          compactThreshold: 0.8,
+          summaryBudgetRatio: 0.05,
+          overflowRecovery: {
+            enabled: true,
+            safetyMarginRatio: 0.05,
+            maxAttempts: 3,
+            interactiveLatestTurnCompression: "summarize",
+            nonInteractiveLatestTurnCompression: "truncate",
+          },
+        },
+      },
+      profiles: {},
+      callSites: {},
+      pricingOverrides: [],
+    },
+    rateLimit: { maxRequestsPerMinute: 0 },
+  }),
+  loadRawConfig: () => ({}),
+  saveRawConfig: () => {},
+  invalidateConfigCache: () => {},
+}));
+
+mock.module("../prompts/system-prompt.js", () => ({
+  buildSystemPrompt: () => "system prompt",
+}));
+
+mock.module("../permissions/trust-store.js", () => ({
+  clearCache: () => {},
+}));
+
+mock.module("../security/secret-allowlist.js", () => ({
+  resetAllowlist: () => {},
+}));
+
+let mockDbMessages: Array<{
+  id: string;
+  role: string;
+  content: string;
+  createdAt: number;
+  metadata?: string | null;
+}> = [];
+let mockConversation: Record<string, unknown> | null = null;
+
+mock.module("../memory/conversation-crud.js", () => ({
+  updateConversationContextWindow: () => {},
+  deleteMessageById: () => {},
+  updateConversationTitle: () => {},
+  updateConversationUsage: () => {},
+  provenanceFromTrustContext: () => ({
+    source: "user",
+    trustContext: undefined,
+  }),
+  getConversationOriginInterface: () => null,
+  getConversationOriginChannel: () => null,
+  getMessages: () => mockDbMessages,
+  getConversation: () => mockConversation,
+  createConversation: () => ({ id: "conv-1" }),
+  addMessage: async () => ({ id: "persisted" }),
+  setConversationCleanedAt: () => {},
+  setConversationOriginChannelIfUnset: () => {},
+  setConversationOriginInterfaceIfUnset: () => {},
+}));
+
+mock.module("../memory/conversation-queries.js", () => ({
+  listConversations: () => [],
+}));
+
+import { Conversation } from "../daemon/conversation.js";
+
+function makeConversation(): Conversation {
+  const provider = {
+    name: "mock",
+    sendMessage: async () => ({
+      content: [],
+      model: "mock",
+      usage: { inputTokens: 0, outputTokens: 0 },
+      stopReason: "end_turn",
+    }),
+  };
+  const conv = new Conversation(
+    "conv-1",
+    provider,
+    "system prompt",
+    4096,
+    () => {},
+    "/tmp",
+  );
+  conv.setTrustContext({ trustClass: "guardian", sourceChannel: "vellum" });
+  return conv;
+}
+
+function textBlocks(content: ReadonlyArray<{ type: string; text?: string }>) {
+  return content
+    .filter((b): b is { type: "text"; text: string } => b.type === "text")
+    .map((b) => b.text);
+}
+
+describe("loadFromDb with cleanedAt", () => {
+  beforeEach(() => {
+    mockDbMessages = [];
+    mockConversation = null;
+  });
+
+  test("strips injection prefixes from pre-clean user content", async () => {
+    const cleanedAt = 1000;
+    mockConversation = {
+      id: "conv-1",
+      contextSummary: null,
+      contextCompactedMessageCount: 0,
+      cleanedAt,
+      totalInputTokens: 0,
+      totalOutputTokens: 0,
+      totalEstimatedCost: 0,
+    };
+    mockDbMessages = [
+      {
+        id: "m1",
+        role: "user",
+        content: JSON.stringify([
+          {
+            type: "text",
+            text: "<channel_capabilities>old</channel_capabilities>",
+          },
+          { type: "text", text: "Hello" },
+        ]),
+        createdAt: 500,
+      },
+      {
+        id: "m2",
+        role: "assistant",
+        content: JSON.stringify([{ type: "text", text: "Hi back" }]),
+        createdAt: 600,
+      },
+      {
+        id: "m3",
+        role: "user",
+        content: JSON.stringify([
+          {
+            type: "text",
+            text: "<channel_capabilities>fresh</channel_capabilities>",
+          },
+          { type: "text", text: "Second turn" },
+        ]),
+        createdAt: 1500,
+      },
+    ];
+
+    const conversation = makeConversation();
+    await conversation.loadFromDb();
+    const messages = conversation.getMessages();
+
+    expect(messages).toHaveLength(3);
+    expect(textBlocks(messages[0].content)).toEqual(["Hello"]);
+    expect(textBlocks(messages[1].content)).toEqual(["Hi back"]);
+    expect(textBlocks(messages[2].content)).toEqual([
+      "<channel_capabilities>fresh</channel_capabilities>",
+      "Second turn",
+    ]);
+  });
+
+  test("skips metadata rehydration for pre-clean messages", async () => {
+    const cleanedAt = 1000;
+    mockConversation = {
+      id: "conv-1",
+      contextSummary: null,
+      contextCompactedMessageCount: 0,
+      cleanedAt,
+      totalInputTokens: 0,
+      totalOutputTokens: 0,
+      totalEstimatedCost: 0,
+    };
+    mockDbMessages = [
+      {
+        id: "m1",
+        role: "user",
+        content: JSON.stringify([{ type: "text", text: "Pre-clean turn" }]),
+        createdAt: 500,
+        metadata: JSON.stringify({
+          pkbContextBlock: "<knowledge_base>stale</knowledge_base>",
+        }),
+      },
+      {
+        id: "m2",
+        role: "assistant",
+        content: JSON.stringify([{ type: "text", text: "Reply" }]),
+        createdAt: 600,
+      },
+      {
+        id: "m3",
+        role: "user",
+        content: JSON.stringify([
+          { type: "text", text: "Mid post-clean turn" },
+        ]),
+        createdAt: 1500,
+        metadata: JSON.stringify({
+          pkbContextBlock: "<knowledge_base>kept</knowledge_base>",
+        }),
+      },
+      {
+        id: "m4",
+        role: "assistant",
+        content: JSON.stringify([{ type: "text", text: "Tail reply" }]),
+        createdAt: 1600,
+      },
+    ];
+
+    const conversation = makeConversation();
+    await conversation.loadFromDb();
+    const messages = conversation.getMessages();
+
+    expect(textBlocks(messages[0].content)).toEqual(["Pre-clean turn"]);
+    expect(textBlocks(messages[2].content).join("\n")).toContain(
+      "<knowledge_base>kept</knowledge_base>",
+    );
+  });
+
+  test("leaves messages untouched when cleanedAt is null", async () => {
+    mockConversation = {
+      id: "conv-1",
+      contextSummary: null,
+      contextCompactedMessageCount: 0,
+      cleanedAt: null,
+      totalInputTokens: 0,
+      totalOutputTokens: 0,
+      totalEstimatedCost: 0,
+    };
+    mockDbMessages = [
+      {
+        id: "m1",
+        role: "user",
+        content: JSON.stringify([
+          {
+            type: "text",
+            text: "<channel_capabilities>kept</channel_capabilities>",
+          },
+          { type: "text", text: "Hi" },
+        ]),
+        createdAt: 500,
+      },
+    ];
+
+    const conversation = makeConversation();
+    await conversation.loadFromDb();
+    const messages = conversation.getMessages();
+
+    expect(textBlocks(messages[0].content)).toEqual([
+      "<channel_capabilities>kept</channel_capabilities>",
+      "Hi",
+    ]);
+  });
+});

package/src/__tests__/conversation-load-history-repair.test.ts

@@ -10,7 +10,7 @@ mock.module("../util/logger.js", () => ({
 
 mock.module("../providers/registry.js", () => ({
   getProvider: () => ({ name: "mock-provider" }),
-  initializeProviders: () => {},
+  initializeProviders: async () => {},
 }));
 
 mock.module("../config/loader.js", () => ({

package/src/__tests__/conversation-media-retry.test.ts

@@ -23,7 +23,11 @@ function makeImageBlockWithSize(
 ): Extract<ContentBlock, { type: "image" }> {
   return {
     type: "image",
-    source: { type: "base64", media_type: "image/png", data: "A".repeat(dataLength) },
+    source: {
+      type: "base64",
+      media_type: "image/png",
+      data: "A".repeat(dataLength),
+    },
   };
 }
 
@@ -103,16 +107,19 @@ describe("stripMediaPayloadsForRetry", () => {
   // ---------------------------------------------------------------------------
 
   test("budget-aware: keeps images that fit within token budget", () => {
-    // Non-Anthropic estimation: estimateTextTokens(base64Data) + overhead (~19 tokens).
-    // Data length 4000 → 1000 data tokens + 19 overhead ≈ 1019 tokens/image.
-    // Budget of 3500 allows 3 images (3 * 1019 = 3057 <= 3500) but not 4.
-    const images = Array.from({ length: 5 }, () => makeImageBlockWithSize(4000));
+    // Dimension-based estimation: when the base64 data has no parseable image
+    // header, fall back to IMAGE_MAX_TOKENS (1600) + overhead (~19 tokens) ≈
+    // 1619 tokens/image. Budget of 5000 allows 3 images (3 * 1619 = 4857
+    // <= 5000) but not 4 (4 * 1619 = 6476 > 5000).
+    const images = Array.from({ length: 5 }, () =>
+      makeImageBlockWithSize(4000),
+    );
     const messages: Message[] = [
       makeUserMessage({ type: "text", text: "describe these" }, ...images),
     ];
 
     const result = stripMediaPayloadsForRetry(messages, {
-      mediaTokenBudget: 3500,
+      mediaTokenBudget: 5000,
       providerName: "mock",
     });
     expect(result.modified).toBe(true);
@@ -120,7 +127,9 @@ describe("stripMediaPayloadsForRetry", () => {
     const content = result.messages[0].content;
     const keptImages = content.filter((b) => b.type === "image");
     const stubs = content.filter(
-      (b) => b.type === "text" && (b as { text: string }).text.includes("Image omitted"),
+      (b) =>
+        b.type === "text" &&
+        (b as { text: string }).text.includes("Image omitted"),
     );
     expect(keptImages.length).toBe(3);
     expect(stubs.length).toBe(2);
@@ -174,7 +183,9 @@ describe("stripMediaPayloadsForRetry", () => {
     const content = result.messages[0].content;
     const keptImages = content.filter((b) => b.type === "image");
     const stubs = content.filter(
-      (b) => b.type === "text" && (b as { text: string }).text.includes("Image omitted"),
+      (b) =>
+        b.type === "text" &&
+        (b as { text: string }).text.includes("Image omitted"),
     );
     expect(keptImages.length).toBe(3);
     expect(stubs.length).toBe(2);