@vellumai/assistant 0.8.3 → 0.8.4

package/src/__tests__/conversation-agent-loop-overflow.test.ts

@@ -195,6 +195,9 @@ mock.module("../memory/conversation-crud.js", () => ({
   updateMessageContent: () => {},
   updateMessageMetadata: () => {},
   clearStrippedInjectionMetadataForConversation: () => {},
+  setLastNotifiedInferenceProfile: () => {},
+  getLastUserTimestampBefore: () => 0,
+  getConversationOverrideProfileFromRow: () => undefined,
 }));
 
 afterAll(() => {
@@ -301,6 +304,7 @@ mock.module("../daemon/history-repair.js", () => ({
 }));
 
 const recordUsageMock = mock((..._args: unknown[]) => {});
+const setAgentLoopExitReasonOnLatestLogMock = mock(() => {});
 mock.module("../daemon/conversation-usage.js", () => ({
   recordUsage: recordUsageMock,
 }));
@@ -349,12 +353,23 @@ mock.module("../workspace/git-service.js", () => ({
 }));
 
 mock.module("../daemon/conversation-error.js", () => ({
-  classifyConversationError: (_err: unknown, _ctx: unknown) => ({
-    code: "CONVERSATION_PROCESSING_FAILED",
-    userMessage: "Something went wrong processing your message.",
-    retryable: false,
-    errorCategory: "processing_failed",
-  }),
+  classifyConversationError: (err: unknown, _ctx: unknown) => {
+    const message = err instanceof Error ? err.message : String(err);
+    if (/context.?length.?exceeded/i.test(message)) {
+      return {
+        code: "CONTEXT_TOO_LARGE",
+        userMessage: "Context too large.",
+        retryable: false,
+        errorCategory: "context_too_large",
+      };
+    }
+    return {
+      code: "CONVERSATION_PROCESSING_FAILED",
+      userMessage: "Something went wrong processing your message.",
+      retryable: false,
+      errorCategory: "processing_failed",
+    };
+  },
   isUserCancellation: (err: unknown, ctx: { aborted?: boolean }) => {
     if (!ctx.aborted) return false;
     if (err instanceof DOMException && err.name === "AbortError") return true;
@@ -394,6 +409,7 @@ mock.module("../agent/message-types.js", () => ({
 mock.module("../memory/llm-request-log-store.js", () => ({
   recordRequestLog: () => {},
   backfillMessageIdOnLogs: () => {},
+  setAgentLoopExitReasonOnLatestLog: setAgentLoopExitReasonOnLatestLogMock,
 }));
 
 mock.module("../memory/archive-store.js", () => ({
@@ -616,6 +632,7 @@ beforeEach(() => {
   mockOverflowAction = "fail_gracefully";
   mockApplyRuntimeInjections = (msgs) => msgs;
   recordUsageMock.mockClear();
+  setAgentLoopExitReasonOnLatestLogMock.mockClear();
   // Reset the plugin registry and re-register every default so the
   // orchestrator's pipelines (`overflowReduce`, `persistence`, …) dispatch to
   // the default middleware, which in turn hits the mocked collaborators
@@ -1907,6 +1924,10 @@ describe("session-agent-loop overflow recovery (JARVIS-110)", () => {
     // After exhausting mid-loop attempts, the convergence loop should
     // have been triggered (contextTooLargeDetected set to true)
     expect(convergenceReducerCalled).toBe(true);
+    expect(setAgentLoopExitReasonOnLatestLogMock).toHaveBeenCalledWith(
+      "test-conv",
+      "context_too_large",
+    );
   });
 
   // ── Test 9 ────────────────────────────────────────────────────────
@@ -2068,6 +2089,10 @@ describe("session-agent-loop overflow recovery (JARVIS-110)", () => {
 
     // Agent loop: 1 initial + 3 mid-loop re-entries + 2 convergence re-runs = 6 calls
     expect(agentLoopCallCount).toBe(6);
+    expect(setAgentLoopExitReasonOnLatestLogMock).toHaveBeenCalledWith(
+      "test-conv",
+      "context_too_large",
+    );
   });
 
   // ── Test 8 ────────────────────────────────────────────────────────

package/src/__tests__/conversation-agent-loop.test.ts

@@ -283,6 +283,7 @@ let mockSlackChronologicalContext: {
   renderedMessages: Array<{
     message: Message;
     sourceChannelTs: string | null;
+    tagLineProvenance: "none" | "slack-reaction" | "slack-timezone-message";
   }>;
   messages: Message[];
   compactableStartIndex: number;
@@ -387,6 +388,7 @@ mock.module("../daemon/history-repair.js", () => ({
 const recordUsageMock = mock(() => {});
 const recordRequestLogMock = mock(() => {});
 const backfillMessageIdOnLogsMock = mock(() => {});
+const setAgentLoopExitReasonOnLatestLogMock = mock(() => {});
 mock.module("../daemon/conversation-usage.js", () => ({
   recordUsage: recordUsageMock,
 }));
@@ -484,6 +486,7 @@ mock.module("../memory/archive-store.js", () => ({
 mock.module("../memory/llm-request-log-store.js", () => ({
   recordRequestLog: recordRequestLogMock,
   backfillMessageIdOnLogs: backfillMessageIdOnLogsMock,
+  setAgentLoopExitReasonOnLatestLog: setAgentLoopExitReasonOnLatestLogMock,
 }));
 
 let mockHasProactiveArtifactCompleted = true;
@@ -660,6 +663,7 @@ beforeEach(() => {
   recordUsageMock.mockClear();
   recordRequestLogMock.mockClear();
   backfillMessageIdOnLogsMock.mockClear();
+  setAgentLoopExitReasonOnLatestLogMock.mockClear();
   syncMessageToDiskMock.mockClear();
   rebuildConversationDiskViewFromDbStateMock.mockClear();
   updateMessageMetadataMock.mockClear();
@@ -2300,6 +2304,10 @@ describe("session-agent-loop", () => {
 
       const handoff = events.find((e) => e.type === "generation_handoff");
       expect(handoff).toBeDefined();
+      expect(setAgentLoopExitReasonOnLatestLogMock).toHaveBeenCalledWith(
+        "test-conv",
+        "checkpoint_handoff",
+      );
     });
 
     test("continues when canHandoffAtCheckpoint returns false", async () => {
@@ -2359,6 +2367,10 @@ describe("session-agent-loop", () => {
 
       const handoff = events.find((e) => e.type === "generation_handoff");
       expect(handoff).toBeUndefined();
+      expect(setAgentLoopExitReasonOnLatestLogMock).not.toHaveBeenCalledWith(
+        "test-conv",
+        "checkpoint_handoff",
+      );
       const complete = events.find((e) => e.type === "message_complete");
       expect(complete).toBeDefined();
     });
@@ -2903,11 +2915,8 @@ describe("session-agent-loop", () => {
       // (from the mocked `addMessage` -> `{ id: "mock-msg-id" }`) into the
       // backfill primitive, scoped to this conversation.
       expect(backfillMessageIdOnLogsMock).toHaveBeenCalledTimes(1);
-      const backfillCall =
-        backfillMessageIdOnLogsMock.mock.calls[0] as unknown as [
-          string,
-          string,
-        ];
+      const backfillCall = backfillMessageIdOnLogsMock.mock
+        .calls[0] as unknown as [string, string];
       expect(backfillCall[0]).toBe("test-conv");
       expect(backfillCall[1]).toBe("mock-msg-id");
     });
@@ -3023,6 +3032,7 @@ describe("session-agent-loop", () => {
             "1700000020.000000",
             "1700000030.000000",
           ][index]!,
+          tagLineProvenance: "none",
         })),
         compactableStartIndex: 0,
       };
@@ -3122,6 +3132,7 @@ describe("session-agent-loop", () => {
             "1700000020.000000",
             "1700000030.000000",
           ][index]!,
+          tagLineProvenance: "none",
         })),
         compactableStartIndex: 0,
       };
@@ -3238,6 +3249,7 @@ describe("session-agent-loop", () => {
             "1700000030.000000",
             "1700000040.000000",
           ][index]!,
+          tagLineProvenance: "none",
         })),
         compactableStartIndex: 0,
       };
@@ -3343,9 +3355,10 @@ describe("session-agent-loop", () => {
               {
                 message: firstSummaryMessage,
                 sourceChannelTs: null,
+                tagLineProvenance: "none",
               },
-              mockSlackChronologicalContext.renderedMessages[2],
-              mockSlackChronologicalContext.renderedMessages[3],
+              mockSlackChronologicalContext!.renderedMessages[2],
+              mockSlackChronologicalContext!.renderedMessages[3],
             ],
             messages: firstCompactedMessages,
             compactableStartIndex: 1,
@@ -3384,6 +3397,7 @@ describe("session-agent-loop", () => {
             "1700000020.000000",
             "1700000030.000000",
           ][index]!,
+          tagLineProvenance: "none",
         })),
         compactableStartIndex: 0,
       };
@@ -3541,6 +3555,7 @@ describe("session-agent-loop", () => {
               ],
             },
             sourceChannelTs: null,
+            tagLineProvenance: "none",
           },
           {
             message: {
@@ -3548,6 +3563,7 @@ describe("session-agent-loop", () => {
               content: [{ type: "text", text: "after watermark reply" }],
             },
             sourceChannelTs: "1700000020.000000",
+            tagLineProvenance: "none",
           },
         ],
         compactableStartIndex: 1,
@@ -3642,6 +3658,7 @@ describe("session-agent-loop", () => {
               ],
             },
             sourceChannelTs: null,
+            tagLineProvenance: "none",
           },
           {
             message: {
@@ -3654,6 +3671,7 @@ describe("session-agent-loop", () => {
               ],
             },
             sourceChannelTs: "1700000121.000000",
+            tagLineProvenance: "none",
           },
         ],
         compactableStartIndex: 1,

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

@@ -22,7 +22,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-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", () => ({