@vellumai/assistant 0.8.3 → 0.8.5

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

@@ -159,8 +159,8 @@ mock.module("../daemon/disk-pressure-policy.js", () => ({
 const updateMessageMetadataMock = mock(
   (_id: string, _updates: Record<string, unknown>) => {},
 );
-const clearStrippedInjectionMetadataForConversationMock = mock(
-  (_conversationId: string) => {},
+const setConversationHistoryStrippedAtMock = mock(
+  (_conversationId: string, _historyStrippedAt: number | null) => {},
 );
 const updateConversationSlackContextWatermarkMock = mock(
   (_conversationId: string, _watermarkTs: string, _compactedAt?: number) => {},
@@ -180,8 +180,7 @@ mock.module("../memory/conversation-crud.js", () => ({
   setConversationOriginChannelIfUnset: () => {},
   updateConversationUsage: () => {},
   updateMessageMetadata: updateMessageMetadataMock,
-  clearStrippedInjectionMetadataForConversation:
-    clearStrippedInjectionMetadataForConversationMock,
+  setConversationHistoryStrippedAt: setConversationHistoryStrippedAtMock,
   getMessages: () => [],
   getConversation: () => mockConversationRow,
   provenanceFromTrustContext: () => ({
@@ -283,6 +282,7 @@ let mockSlackChronologicalContext: {
   renderedMessages: Array<{
     message: Message;
     sourceChannelTs: string | null;
+    tagLineProvenance: "none" | "slack-reaction" | "slack-timezone-message";
   }>;
   messages: Message[];
   compactableStartIndex: number;
@@ -387,6 +387,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 +485,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 +662,7 @@ beforeEach(() => {
   recordUsageMock.mockClear();
   recordRequestLogMock.mockClear();
   backfillMessageIdOnLogsMock.mockClear();
+  setAgentLoopExitReasonOnLatestLogMock.mockClear();
   syncMessageToDiskMock.mockClear();
   rebuildConversationDiskViewFromDbStateMock.mockClear();
   updateMessageMetadataMock.mockClear();
@@ -680,10 +683,8 @@ beforeEach(() => {
   mockHasProactiveArtifactCompleted = true;
   mockTryClaimProactiveArtifactTrigger = false;
   runProactiveArtifactJobMock.mockClear();
-  clearStrippedInjectionMetadataForConversationMock.mockClear();
-  clearStrippedInjectionMetadataForConversationMock.mockImplementation(
-    () => {},
-  );
+  setConversationHistoryStrippedAtMock.mockClear();
+  setConversationHistoryStrippedAtMock.mockImplementation(() => {});
   applyRuntimeInjectionsMock.mockClear();
   buildUnifiedTurnContextBlockMock.mockClear();
   resolveTurnTimezoneContextMock.mockClear();
@@ -1214,20 +1215,8 @@ describe("session-agent-loop", () => {
       await runAgentLoopImpl(ctx, "hello", "msg-1", (msg) => events.push(msg));
 
       expect(recordRequestLogMock).toHaveBeenCalledTimes(1);
-      const call = recordRequestLogMock.mock.calls[0] as unknown as [
-        string,
-        string,
-        string,
-        undefined,
-        string,
-      ];
-      expect(call).toEqual([
-        "test-conv",
-        JSON.stringify(rawRequest),
-        JSON.stringify(rawResponse),
-        undefined,
-        "fireworks",
-      ]);
+      const call = recordRequestLogMock.mock.calls[0] as unknown as unknown[];
+      expect(call[4]).toBe("fireworks");
     });
 
     test("record request log falls back to the runtime provider when no actual provider is supplied", async () => {
@@ -1373,20 +1362,9 @@ describe("session-agent-loop", () => {
       await runAgentLoopImpl(ctx, "hello", "msg-1", (msg) => events.push(msg));
 
       expect(recordRequestLogMock).toHaveBeenCalledTimes(1);
-      const call = recordRequestLogMock.mock.calls[0] as unknown as [
-        string,
-        string,
-        string,
-        undefined,
-        string,
-      ];
-      expect(call).toEqual([
-        "test-conv",
-        JSON.stringify(rawRequest),
-        JSON.stringify(rawResponse),
-        undefined,
-        "openai",
-      ]);
+      const call = recordRequestLogMock.mock.calls[0] as unknown as unknown[];
+      expect(call[1]).toBe(JSON.stringify(rawRequest));
+      expect(call[2]).toBe(JSON.stringify(rawResponse));
     });
   });
 
@@ -2038,6 +2016,154 @@ describe("session-agent-loop", () => {
       expect(complete).toBeDefined();
     });
 
+    test("emits budget_yield_unrecovered when auto_compress rerun yields at mid-loop budget", async () => {
+      // Regression test for the silent-stall failure mode:
+      // when every recovery layer has been applied (tier reducer
+      // exhausted + auto_compress_latest_turn emergency compaction)
+      // and the final `agentLoop.run` STILL yields at the mid-loop
+      // budget checkpoint, the orchestrator used to fall through to
+      // post-turn cleanup with NO `agent_loop_exit_reason` emitted —
+      // the turn just stopped mid-action and `llm_request_logs` showed
+      // a NULL exit reason on the final row. We now emit
+      // `budget_yield_unrecovered` so the inspector and dashboards can
+      // attribute the silent stall.
+      const events: ServerMessage[] = [];
+      let callCount = 0;
+
+      // Reducer exhausts all 4 tiers on first call so the convergence
+      // loop runs exactly one iteration before falling through to
+      // the auto_compress_latest_turn branch.
+      mockReducerStepFn = (msgs: Message[]) => ({
+        messages: msgs,
+        tier: "injection_downgrade",
+        state: {
+          appliedTiers: [
+            "forced_compaction",
+            "tool_result_truncation",
+            "media_stubbing",
+            "injection_downgrade",
+          ],
+          injectionMode: "minimal",
+          exhausted: true,
+        },
+        estimatedTokens: 120_000,
+      });
+
+      mockOverflowAction = "auto_compress_latest_turn";
+
+      // Sits between the preflight budget (preflightBudget =
+      // 100k * 0.95 = 95k — anything above triggers preflight reducer
+      // *before* we get to the convergence/auto_compress path under
+      // test) and the mid-loop threshold (preflightBudget * 0.85 =
+      // ≈80.75k — anything above flips yieldedForBudget on a checkpoint
+      // call). 90k satisfies both so the path reaches call 3.
+      mockEstimateTokens = 90_000;
+
+      const agentLoopRun: AgentLoopRun = async (
+        messages,
+        onEvent,
+        _signal,
+        _reqId,
+        onCheckpoint,
+      ) => {
+        callCount++;
+        if (callCount <= 2) {
+          // Calls 1 (initial) and 2 (convergence rerun): error so
+          // `state.contextTooLargeDetected` stays true through
+          // convergence exit and we enter the auto_compress branch.
+          onEvent({
+            type: "error",
+            error: new Error("context_length_exceeded"),
+          });
+          onEvent({
+            type: "usage",
+            inputTokens: 100,
+            outputTokens: 0,
+            model: "test-model",
+            providerDurationMs: 50,
+          });
+          return messages;
+        }
+        // Call 3: the auto_compress_latest_turn rerun. Invoke
+        // onCheckpoint so the orchestrator's mid-loop budget check
+        // flips `yieldedForBudget` to true, then return without
+        // finishing — mirroring what AgentLoop.run does when its
+        // checkpoint returns "yield".
+        if (onCheckpoint) {
+          await onCheckpoint({
+            turnIndex: 0,
+            toolCount: 1,
+            hasToolUse: true,
+            history: messages,
+          });
+        }
+        return messages;
+      };
+
+      const ctx = makeCtx({
+        agentLoopRun,
+        hasNoClient: true,
+        contextWindowManager: {
+          shouldCompact: () => ({ needed: false, estimatedTokens: 0 }),
+          maybeCompact: async () => ({
+            compacted: true,
+            messages: [
+              { role: "user", content: [{ type: "text", text: "Hello" }] },
+            ] as Message[],
+            compactedPersistedMessages: 3,
+            summaryText: "Compressed summary",
+            previousEstimatedInputTokens: 120000,
+            estimatedInputTokens: 30000,
+            maxInputTokens: 100000,
+            thresholdTokens: 80000,
+            compactedMessages: 5,
+            summaryCalls: 1,
+            summaryInputTokens: 300,
+            summaryOutputTokens: 100,
+            summaryModel: "mock-model",
+          }),
+        } as unknown as AgentLoopConversationContext["contextWindowManager"],
+      });
+
+      await runAgentLoopImpl(ctx, "hello", "msg-1", (msg) => events.push(msg));
+
+      // Observability emit: exit reason was stamped onto the latest
+      // llm_request_logs row.
+      expect(setAgentLoopExitReasonOnLatestLogMock).toHaveBeenCalledWith(
+        "test-conv",
+        "budget_yield_unrecovered",
+      );
+
+      // We did NOT also emit context_too_large — the auto_compress
+      // branch resets `contextTooLargeDetected` before its rerun and
+      // the rerun's yield-for-budget keeps it false, so the error
+      // branch above stays skipped.
+      expect(setAgentLoopExitReasonOnLatestLogMock).not.toHaveBeenCalledWith(
+        "test-conv",
+        "context_too_large",
+      );
+
+      // User-facing emit: the classified BUDGET_YIELD_UNRECOVERED
+      // error is sent to the client so the UI can render a notice
+      // instead of leaving the turn looking like a silent ghost. The
+      // assistant-side notice persistence is exercised in the overflow
+      // suite (`conversation-agent-loop-overflow.test.ts`); this test
+      // owns the observability + emit contract.
+      const conversationError = events.find(
+        (e) => e.type === "conversation_error",
+      );
+      expect(conversationError).toBeDefined();
+      if (conversationError && "code" in conversationError) {
+        expect(conversationError.code).toBe("BUDGET_YIELD_UNRECOVERED");
+        expect(conversationError.retryable).toBe(true);
+        expect(conversationError.errorCategory).toBe(
+          "budget_yield_unrecovered",
+        );
+      } else {
+        throw new Error("conversation_error missing `code` field");
+      }
+    });
+
     test("recovery loop is bounded by maxAttempts", async () => {
       const events: ServerMessage[] = [];
       let reducerCalls = 0;
@@ -2300,6 +2426,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 +2489,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 +3037,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 +3154,7 @@ describe("session-agent-loop", () => {
             "1700000020.000000",
             "1700000030.000000",
           ][index]!,
+          tagLineProvenance: "none",
         })),
         compactableStartIndex: 0,
       };
@@ -3122,6 +3254,7 @@ describe("session-agent-loop", () => {
             "1700000020.000000",
             "1700000030.000000",
           ][index]!,
+          tagLineProvenance: "none",
         })),
         compactableStartIndex: 0,
       };
@@ -3238,6 +3371,7 @@ describe("session-agent-loop", () => {
             "1700000030.000000",
             "1700000040.000000",
           ][index]!,
+          tagLineProvenance: "none",
         })),
         compactableStartIndex: 0,
       };
@@ -3343,9 +3477,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 +3519,7 @@ describe("session-agent-loop", () => {
             "1700000020.000000",
             "1700000030.000000",
           ][index]!,
+          tagLineProvenance: "none",
         })),
         compactableStartIndex: 0,
       };
@@ -3541,6 +3677,7 @@ describe("session-agent-loop", () => {
               ],
             },
             sourceChannelTs: null,
+            tagLineProvenance: "none",
           },
           {
             message: {
@@ -3548,6 +3685,7 @@ describe("session-agent-loop", () => {
               content: [{ type: "text", text: "after watermark reply" }],
             },
             sourceChannelTs: "1700000020.000000",
+            tagLineProvenance: "none",
           },
         ],
         compactableStartIndex: 1,
@@ -3642,6 +3780,7 @@ describe("session-agent-loop", () => {
               ],
             },
             sourceChannelTs: null,
+            tagLineProvenance: "none",
           },
           {
             message: {
@@ -3654,6 +3793,7 @@ describe("session-agent-loop", () => {
               ],
             },
             sourceChannelTs: "1700000121.000000",
+            tagLineProvenance: "none",
           },
         ],
         compactableStartIndex: 1,
@@ -3751,8 +3891,8 @@ describe("session-agent-loop", () => {
     });
   });
 
-  describe("compaction-strip metadata consistency", () => {
-    test("clears pkbSystemReminderBlock metadata when convergence strip runs", async () => {
+  describe("compaction-strip marker persistence", () => {
+    test("records historyStrippedAt when convergence strip runs", async () => {
       // Reducer: succeed on first call, returning reduced messages.
       mockReducerStepFn = (msgs: Message[]) => ({
         messages: msgs,
@@ -3823,91 +3963,10 @@ describe("session-agent-loop", () => {
 
       await runAgentLoopImpl(ctx, "hello", "msg-1", () => {});
 
-      // The bulk-clear helper must have been called with the conversation id
-      // at least once (one of the three strip sites fired).
-      const clearCalls =
-        clearStrippedInjectionMetadataForConversationMock.mock.calls.filter(
-          (call) => call[0] === "test-conv",
-        );
-      expect(clearCalls.length).toBeGreaterThanOrEqual(1);
-    });
-
-    test("strip-site clear is non-fatal when the helper throws", async () => {
-      clearStrippedInjectionMetadataForConversationMock.mockImplementation(
-        () => {
-          throw new Error("db write failed");
-        },
+      const stripCalls = setConversationHistoryStrippedAtMock.mock.calls.filter(
+        (call) => call[0] === "test-conv",
       );
-
-      mockReducerStepFn = (msgs: Message[]) => ({
-        messages: msgs,
-        tier: "forced_compaction",
-        state: {
-          appliedTiers: ["forced_compaction"],
-          injectionMode: "full",
-          exhausted: false,
-        },
-        estimatedTokens: 5000,
-      });
-
-      let callCount = 0;
-      const agentLoopRun: AgentLoopRun = async (messages, onEvent) => {
-        callCount++;
-        if (callCount === 1) {
-          onEvent({
-            type: "error",
-            error: new Error("context_length_exceeded"),
-          });
-          onEvent({
-            type: "usage",
-            inputTokens: 100,
-            outputTokens: 0,
-            model: "test-model",
-            providerDurationMs: 50,
-          });
-          return [
-            ...messages,
-            {
-              role: "assistant" as const,
-              content: [{ type: "text", text: "partial" }] as ContentBlock[],
-            },
-          ];
-        }
-        onEvent({
-          type: "message_complete",
-          message: {
-            role: "assistant",
-            content: [{ type: "text", text: "recovered" }],
-          },
-        });
-        onEvent({
-          type: "usage",
-          inputTokens: 50,
-          outputTokens: 25,
-          model: "test-model",
-          providerDurationMs: 100,
-        });
-        return [
-          ...messages,
-          {
-            role: "assistant" as const,
-            content: [{ type: "text", text: "recovered" }] as ContentBlock[],
-          },
-        ];
-      };
-
-      const ctx = makeCtx({
-        agentLoopRun,
-        contextWindowManager: {
-          shouldCompact: () => ({ needed: false, estimatedTokens: 0 }),
-          maybeCompact: async () => ({ compacted: false }),
-        } as unknown as AgentLoopConversationContext["contextWindowManager"],
-      });
-
-      // Must not throw — the strip-site clear is wrapped in try/catch.
-      await expect(
-        runAgentLoopImpl(ctx, "hello", "msg-1", () => {}),
-      ).resolves.toBeUndefined();
+      expect(stripCalls.length).toBeGreaterThanOrEqual(1);
     });
   });
 });

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

@@ -110,15 +110,12 @@ mock.module("../tools/skills/skill-tool-factory.js", () => ({
       description: entry.description,
       category: entry.category,
       defaultRiskLevel: RiskLevel.Medium,
+      executionTarget: "sandbox" as const,
       origin: "skill" as const,
       ownerSkillId: skillId,
       ownerSkillVersionHash: versionHash,
       ownerSkillBundled: bundled ?? undefined,
-      getDefinition: () => ({
-        name: entry.name,
-        description: entry.description,
-        input_schema: entry.input_schema as object,
-      }),
+      input_schema: entry.input_schema as object,
       execute: async () => ({ content: "", isError: false }),
     })),
 }));

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);
+  });
+});