@vellumai/assistant 0.6.5 → 0.6.6

package/src/__tests__/context-overflow-policy.test.ts

@@ -31,13 +31,13 @@ describe("resolveOverflowAction", () => {
 
   // ── Interactive defaults ──
 
-  test("interactive session with default config asks for user approval", () => {
+  test("interactive session with default config auto-compresses", () => {
     expect(
       resolveOverflowAction({
         overflowRecovery: DEFAULTS,
         isInteractive: true,
       }),
-    ).toBe("request_user_approval");
+    ).toBe("auto_compress_latest_turn");
   });
 
   // ── Non-interactive defaults ──
@@ -53,7 +53,7 @@ describe("resolveOverflowAction", () => {
 
   // ── Interactive with explicit policies ──
 
-  test("interactive + truncate policy asks for user approval", () => {
+  test("interactive + truncate policy auto-compresses", () => {
     expect(
       resolveOverflowAction({
         overflowRecovery: {
@@ -62,10 +62,10 @@ describe("resolveOverflowAction", () => {
         },
         isInteractive: true,
       }),
-    ).toBe("request_user_approval");
+    ).toBe("auto_compress_latest_turn");
   });
 
-  test("interactive + summarize policy asks for user approval", () => {
+  test("interactive + summarize policy auto-compresses", () => {
     expect(
       resolveOverflowAction({
         overflowRecovery: {
@@ -74,7 +74,7 @@ describe("resolveOverflowAction", () => {
         },
         isInteractive: true,
       }),
-    ).toBe("request_user_approval");
+    ).toBe("auto_compress_latest_turn");
   });
 
   test("interactive + drop policy fails gracefully", () => {
@@ -139,7 +139,7 @@ describe("resolveOverflowAction", () => {
         },
         isInteractive: true,
       }),
-    ).toBe("request_user_approval");
+    ).toBe("auto_compress_latest_turn");
   });
 
   test("non-interactive policy is independent of interactive setting", () => {

package/src/__tests__/context-window-manager.test.ts

@@ -3,16 +3,19 @@ import { describe, expect, test } from "bun:test";
 import type { ContextWindowConfig } from "../config/types.js";
 import { estimateTextTokens } from "../context/token-estimator.js";
 import {
+  clampSummaryAtSectionBoundary,
   CONTEXT_SUMMARY_MARKER,
   ContextWindowManager,
   createContextSummaryMessage,
   getSummaryFromContextMessage,
+  stripCompactionOnlyInjections,
 } from "../context/window-manager.js";
 import type {
   ContentBlock,
   Message,
   Provider,
   ProviderResponse,
+  SendMessageOptions,
 } from "../providers/types.js";
 
 function makeConfig(
@@ -320,12 +323,12 @@ describe("ContextWindowManager", () => {
       provider,
       systemPrompt: "system prompt",
       config: makeConfig({
-        maxInputTokens: 620,
-        targetBudgetRatio: 0.59,
-        compactThreshold: 0.5,
+        maxInputTokens: 2000,
+        targetBudgetRatio: 0.4,
+        compactThreshold: 0.35,
       }),
     });
-    const long = "f".repeat(500);
+    const long = "f".repeat(1500);
     const history: Message[] = [
       {
         role: "user",
@@ -1668,4 +1671,352 @@ describe("ContextWindowManager", () => {
     expect(result.compactedMessages).toBe(3);
     expect(result.messages).toHaveLength(1);
   });
+
+  test("summary provider call includes callSite: conversationSummarization", async () => {
+    // Regression guard for JARVIS-587: without the callSite, the summary
+    // call fell through to `llm.default` (opus + effort=max + thinking
+    // enabled) and exceeded the 30s plugin pipeline budget on ~150k-token
+    // transcripts. The fix is to route the summary call through the
+    // dedicated `conversationSummarization` call-site config.
+    const capturedOptions: (SendMessageOptions | undefined)[] = [];
+    const provider: Provider = {
+      name: "mock",
+      async sendMessage(
+        _messages: Message[],
+        _tools: unknown,
+        _systemPrompt: unknown,
+        options?: SendMessageOptions,
+      ): Promise<ProviderResponse> {
+        capturedOptions.push(options);
+        return {
+          content: [{ type: "text", text: "## Goals\n- summary" }],
+          model: "mock-model",
+          usage: { inputTokens: 50, outputTokens: 10 },
+          stopReason: "end_turn",
+        };
+      },
+    };
+    const manager = new ContextWindowManager({
+      provider,
+      systemPrompt: "system prompt",
+      config: makeConfig({ maxInputTokens: 600 }),
+    });
+    const long = "x".repeat(240);
+    const history: Message[] = [
+      message("user", `u1 ${long}`),
+      message("assistant", `a1 ${long}`),
+      message("user", `u2 ${long}`),
+      message("assistant", `a2 ${long}`),
+      message("user", `u3 ${long}`),
+      message("assistant", `a3 ${long}`),
+    ];
+
+    const result = await manager.maybeCompact(history);
+    expect(result.compacted).toBe(true);
+    expect(capturedOptions.length).toBeGreaterThan(0);
+    for (const options of capturedOptions) {
+      expect(options?.config?.callSite).toBe("conversationSummarization");
+    }
+  });
+});
+
+describe("stripCompactionOnlyInjections", () => {
+  test("removes memory, turn_context, and workspace text blocks from user messages", () => {
+    const messages: Message[] = [
+      {
+        role: "user",
+        content: [
+          {
+            type: "text",
+            text: "<memory __injected>\nrecall notes\n</memory>",
+          },
+          {
+            type: "text",
+            text: "<turn_context>\nActor: Alice\n</turn_context>",
+          },
+          { type: "text", text: "real user content" },
+        ],
+      },
+      {
+        role: "assistant",
+        content: [{ type: "text", text: "assistant reply" }],
+      },
+    ];
+    const stripped = stripCompactionOnlyInjections(messages);
+    expect(stripped).toHaveLength(2);
+    const firstText = (stripped[0].content[0] as { text: string }).text;
+    expect(firstText).toBe("real user content");
+    expect(stripped[0].content).toHaveLength(1);
+  });
+
+  test("drops user messages that become empty after stripping", () => {
+    const messages: Message[] = [
+      {
+        role: "user",
+        content: [
+          { type: "text", text: "<memory __injected>\nonly memory\n</memory>" },
+        ],
+      },
+      { role: "user", content: [{ type: "text", text: "real content" }] },
+    ];
+    const stripped = stripCompactionOnlyInjections(messages);
+    expect(stripped).toHaveLength(1);
+    expect((stripped[0].content[0] as { text: string }).text).toBe(
+      "real content",
+    );
+  });
+
+  test("leaves assistant messages and non-text blocks untouched", () => {
+    const messages: Message[] = [
+      {
+        role: "assistant",
+        content: [
+          {
+            type: "text",
+            text: "<turn_context>\nnot really injected\n</turn_context>",
+          },
+        ],
+      },
+      {
+        role: "user",
+        content: [
+          {
+            type: "tool_result",
+            tool_use_id: "t1",
+            content: "<memory>fake</memory>",
+          },
+          { type: "text", text: "user reply" },
+        ],
+      },
+    ];
+    const stripped = stripCompactionOnlyInjections(messages);
+    expect(stripped).toHaveLength(2);
+    expect((stripped[0].content[0] as { text: string }).text).toContain(
+      "turn_context",
+    );
+    expect(stripped[1].content).toHaveLength(2);
+  });
+
+  test("preserves user prose that merely mentions ambiguous tag names", () => {
+    // Common-word bare tags embedded in legitimate user prose (discussions of
+    // XML, system terminology, etc.) must survive stripping because they are
+    // not shaped like a runtime injection — no leading newline after the
+    // open tag, or other prose surrounds the tag.
+    const messages: Message[] = [
+      {
+        role: "user",
+        content: [
+          {
+            type: "text",
+            text: "<memory> is a tag I'd like to add to my parser",
+          },
+        ],
+      },
+      {
+        role: "user",
+        content: [
+          {
+            type: "text",
+            text: "checking <workspace> usage across the repo, any thoughts?",
+          },
+        ],
+      },
+      {
+        role: "user",
+        content: [
+          {
+            type: "text",
+            text: "what is <knowledge_base> in this context?",
+          },
+        ],
+      },
+      {
+        role: "user",
+        content: [
+          { type: "text", text: "<pkb> sounds like a short name — wrong?" },
+        ],
+      },
+      {
+        role: "user",
+        content: [
+          {
+            type: "text",
+            text: "when the model hits a <system_reminder>, what happens next?",
+          },
+        ],
+      },
+    ];
+    const stripped = stripCompactionOnlyInjections(messages);
+    expect(stripped).toHaveLength(messages.length);
+    for (let i = 0; i < messages.length; i++) {
+      expect(stripped[i].content).toHaveLength(1);
+      expect((stripped[i].content[0] as { text: string }).text).toBe(
+        (messages[i].content[0] as { text: string }).text,
+      );
+    }
+  });
+
+  test("still strips runtime-shaped wrapped blocks for ambiguous tag names", () => {
+    // Bare-tag blocks with a newline after the open tag and a matching close
+    // tag (e.g. `<memory>\n...\n</memory>`) match the wrapped-strip path.
+    // This covers both the current runtime emission shape and blocks
+    // persisted before the `__injected` attribute existed — the prefix list
+    // handles `__injected`-attributed tags, and the wrapped matcher handles
+    // the bare-tag wrap shape.
+    const messages: Message[] = [
+      {
+        role: "user",
+        content: [
+          { type: "text", text: "<memory>\nlegacy recall blob\n</memory>" },
+          { type: "text", text: "actual user content" },
+        ],
+      },
+      {
+        role: "user",
+        content: [
+          {
+            type: "text",
+            text: "<workspace>\nRoot: /home\nFiles: a, b\n</workspace>",
+          },
+          { type: "text", text: "more prose" },
+        ],
+      },
+      {
+        role: "user",
+        content: [
+          {
+            type: "text",
+            text: "<system_reminder>\nread your PKB\n</system_reminder>",
+          },
+          { type: "text", text: "ok" },
+        ],
+      },
+    ];
+    const stripped = stripCompactionOnlyInjections(messages);
+    expect(stripped).toHaveLength(3);
+    for (const msg of stripped) {
+      expect(msg.content).toHaveLength(1);
+    }
+    expect((stripped[0].content[0] as { text: string }).text).toBe(
+      "actual user content",
+    );
+    expect((stripped[1].content[0] as { text: string }).text).toBe(
+      "more prose",
+    );
+    expect((stripped[2].content[0] as { text: string }).text).toBe("ok");
+  });
+
+  test("does not strip a user's inline snippet that is not shaped like an injection", () => {
+    // A user quoting a `<memory>...</memory>` snippet alongside prose in the
+    // SAME text block should survive — the block does not start with
+    // `<memory>\n` (there's surrounding prose) so the wrapped-tag match
+    // does not trigger.
+    const messages: Message[] = [
+      {
+        role: "user",
+        content: [
+          {
+            type: "text",
+            text: "Here's the XML I'm working with: <memory>x</memory> — what do you think?",
+          },
+        ],
+      },
+    ];
+    const stripped = stripCompactionOnlyInjections(messages);
+    expect(stripped).toHaveLength(1);
+    expect((stripped[0].content[0] as { text: string }).text).toContain(
+      "<memory>x</memory>",
+    );
+  });
+});
+
+describe("summarizer input excludes runtime injections", () => {
+  test("maybeCompact does not pass memory/turn_context text to the summarizer", async () => {
+    const seenPrompts: string[] = [];
+    const provider = createProvider((messages) => {
+      for (const msg of messages) {
+        for (const block of msg.content) {
+          if (block.type === "text") seenPrompts.push(block.text);
+        }
+      }
+      return {
+        content: [
+          {
+            type: "text",
+            text: "## Facts Worth Remembering\n- summary produced",
+          },
+        ],
+        model: "mock",
+        usage: { inputTokens: 100, outputTokens: 25 },
+        stopReason: "end_turn",
+      };
+    });
+    const manager = new ContextWindowManager({
+      provider,
+      systemPrompt: "system prompt",
+      config: makeConfig({
+        maxInputTokens: 2000,
+        targetBudgetRatio: 0.4,
+        compactThreshold: 0.35,
+      }),
+    });
+    const long = "x".repeat(1500);
+    const memoryBlob =
+      "<memory __injected>\nBOB_ATTENDED_STANDUP_YESTERDAY\n</memory>";
+    const turnCtx =
+      "<turn_context>\nACTOR_METADATA_THAT_SHOULD_NOT_LEAK\n</turn_context>";
+    const history: Message[] = [
+      {
+        role: "user",
+        content: [
+          { type: "text", text: memoryBlob },
+          { type: "text", text: turnCtx },
+          { type: "text", text: `u1 ${long}` },
+        ],
+      },
+      message("assistant", `a1 ${long}`),
+      message("user", `u2 ${long}`),
+      message("assistant", `a2 ${long}`),
+      message("user", `u3 ${long}`),
+    ];
+
+    const result = await manager.maybeCompact(history);
+    expect(result.compacted).toBe(true);
+    const joined = seenPrompts.join("\n");
+    expect(joined).not.toContain("BOB_ATTENDED_STANDUP_YESTERDAY");
+    expect(joined).not.toContain("ACTOR_METADATA_THAT_SHOULD_NOT_LEAK");
+    expect(joined).not.toContain("<memory __injected>");
+    expect(joined).not.toContain("<turn_context>");
+    // Real conversation content should survive — at least one of the
+    // middle turns (whose header/body is short enough to fit within the
+    // capped transcript budget) should appear in the summarizer input.
+    expect(joined).toMatch(/u2 |a1 /);
+  });
+});
+
+describe("clampSummaryAtSectionBoundary", () => {
+  test("returns the input unchanged when under the limit", () => {
+    const summary = "## Decisions\nWe decided to ship.";
+    expect(clampSummaryAtSectionBoundary(summary, 1000)).toBe(summary);
+  });
+
+  test("truncates at a `## ` boundary when one exists in the allowed region", () => {
+    const keeper = "## Facts\n" + "a".repeat(200);
+    const dropped = "## Open Threads\n" + "b".repeat(500);
+    const summary = `${keeper}\n${dropped}`;
+    const maxChars = keeper.length + 20;
+    const clamped = clampSummaryAtSectionBoundary(summary, maxChars);
+    expect(clamped.endsWith("...")).toBe(true);
+    expect(clamped).not.toContain("## Open Threads");
+    expect(clamped).toContain("## Facts");
+    // No mid-header cut: nothing that looks like a partial heading.
+    expect(/##\s*$/.test(clamped)).toBe(false);
+  });
+
+  test("falls back to a hard cut when no section boundary is past the midpoint", () => {
+    const body = "no section headers in this output " + "z".repeat(1000);
+    const clamped = clampSummaryAtSectionBoundary(body, 100);
+    expect(clamped.endsWith("...")).toBe(true);
+    expect(clamped.length).toBeLessThanOrEqual(100);
+  });
 });

package/src/__tests__/conversation-abort-tool-results.test.ts

@@ -25,7 +25,7 @@ mock.module("../providers/registry.js", () => ({
 mock.module("../config/loader.js", () => ({
   getConfig: () => ({
     ui: {},
-    
+
     llm: {
       default: {
         provider: "mock-provider",
@@ -168,6 +168,9 @@ mock.module("../agent/loop.js", () => ({
     getToolTokenBudget() {
       return 0;
     }
+    getResolvedTools() {
+      return [];
+    }
     getActiveModel() {
       return undefined;
     }

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

@@ -18,6 +18,7 @@ import type {
   CheckpointInfo,
 } from "../agent/loop.js";
 import type { ServerMessage } from "../daemon/message-protocol.js";
+import { resetPluginRegistryAndRegisterDefaults } from "../plugins/defaults/index.js";
 import type { ContentBlock, Message } from "../providers/types.js";
 
 // ── Module mocks (must precede imports of the module under test) ─────
@@ -71,12 +72,23 @@ mock.module("../config/loader.js", () => ({
 // Token estimator — controllable per-test via mockEstimateTokens.
 // Can be a number (constant), a no-arg function, or a function that
 // receives the messages array for dynamic behavior based on content.
+// Both the calibrated entry point (`estimatePromptTokens`, used in the
+// convergence path) and the raw entry point (`estimatePromptTokensRaw`,
+// used by the default `tokenEstimate` plugin pipeline for preflight/mid-
+// loop) are stubbed so either call site can drive the test.
 let mockEstimateTokens: number | ((msgs?: Message[]) => number) = 1000;
 mock.module("../context/token-estimator.js", () => ({
   estimatePromptTokens: (msgs: Message[]) =>
     typeof mockEstimateTokens === "function"
       ? mockEstimateTokens(msgs)
       : mockEstimateTokens,
+  estimatePromptTokensRaw: (msgs: Message[]) =>
+    typeof mockEstimateTokens === "function"
+      ? mockEstimateTokens(msgs)
+      : mockEstimateTokens,
+  // Default plugin multiplies-in tool tokens via this helper; 0 keeps the
+  // stubbed raw value unchanged.
+  estimateToolsTokens: () => 0,
   // Conversation agent loop now calls this helper to canonicalize the
   // provider key shared with the calibration system. The tests here
   // don't exercise that path, so a passthrough mock is fine.
@@ -126,27 +138,6 @@ mock.module("../daemon/context-overflow-policy.js", () => ({
   resolveOverflowAction: () => mockOverflowAction,
 }));
 
-// Approval: default to denied
-let mockApprovalResult = { approved: false };
-mock.module("../daemon/context-overflow-approval.js", () => ({
-  requestCompressionApproval: async () => mockApprovalResult,
-  CONTEXT_OVERFLOW_TOOL_NAME: "context_overflow_compression",
-}));
-
-let hookBlocked = false;
-let hookBlockedBy = "";
-
-mock.module("../hooks/manager.js", () => ({
-  getHookManager: () => ({
-    trigger: async (hookName: string) => {
-      if (hookName === "pre-message" && hookBlocked) {
-        return { blocked: true, blockedBy: hookBlockedBy };
-      }
-      return { blocked: false };
-    },
-  }),
-}));
-
 mock.module("../memory/conversation-crud.js", () => ({
   getConversationType: () => "default",
   setConversationOriginChannelIfUnset: () => {},
@@ -174,7 +165,7 @@ mock.module("../memory/conversation-crud.js", () => ({
   getMessageById: () => null,
   updateMessageContent: () => {},
   updateMessageMetadata: () => {},
-  clearPkbSystemReminderMetadataForConversation: () => {},
+  clearStrippedInjectionMetadataForConversation: () => {},
 }));
 
 mock.module("../memory/retriever.js", () => ({
@@ -380,7 +371,9 @@ type AgentLoopRun = (
   onEvent: (event: AgentEvent) => void,
   signal?: AbortSignal,
   requestId?: string,
-  onCheckpoint?: (checkpoint: CheckpointInfo) => CheckpointDecision,
+  onCheckpoint?: (
+    checkpoint: CheckpointInfo,
+  ) => CheckpointDecision | Promise<CheckpointDecision>,
 ) => Promise<Message[]>;
 
 function makeCtx(
@@ -410,6 +403,7 @@ function makeCtx(
     agentLoop: {
       run: agentLoopRun,
       getToolTokenBudget: () => 0,
+      getResolvedTools: () => [],
       // Tests in this file don't exercise calibration, so returning
       // undefined is fine — the estimator falls back to the per-provider
       // aggregate key.
@@ -570,14 +564,16 @@ function buildLongConversation(messageCount: number): Message[] {
 // ── Tests ────────────────────────────────────────────────────────────
 
 beforeEach(() => {
-  hookBlocked = false;
-  hookBlockedBy = "";
   mockEstimateTokens = 1000;
   mockReducerStepFn = null;
   mockOverflowAction = "fail_gracefully";
-  mockApprovalResult = { approved: false };
   mockApplyRuntimeInjections = (msgs) => msgs;
   recordUsageMock.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
+  // (`reduceContextOverflow`, `syncMessageToDisk`, …) these tests install.
+  resetPluginRegistryAndRegisterDefaults();
 });
 
 describe("session-agent-loop overflow recovery (JARVIS-110)", () => {
@@ -1393,7 +1389,7 @@ describe("session-agent-loop overflow recovery (JARVIS-110)", () => {
           // Call onCheckpoint — this should trigger the mid-loop budget check
           // which sees 170_000 > 161_500 and returns "yield"
           if (onCheckpoint) {
-            const decision = onCheckpoint({
+            const decision = await onCheckpoint({
               turnIndex: 0,
               toolCount: 1,
               hasToolUse: true,
@@ -1567,7 +1563,7 @@ describe("session-agent-loop overflow recovery (JARVIS-110)", () => {
             });
 
             if (onCheckpoint) {
-              const decision = onCheckpoint({
+              const decision = await onCheckpoint({
                 turnIndex: i,
                 toolCount: 1,
                 hasToolUse: true,
@@ -1751,7 +1747,7 @@ describe("session-agent-loop overflow recovery (JARVIS-110)", () => {
 
       // Always yield at checkpoint — simulates compaction not helping
       if (onCheckpoint) {
-        const decision = onCheckpoint({
+        const decision = await onCheckpoint({
           turnIndex: 0,
           toolCount: 1,
           hasToolUse: true,
@@ -1907,7 +1903,7 @@ describe("session-agent-loop overflow recovery (JARVIS-110)", () => {
 
       // Always yield at checkpoint — simulates reduction not helping enough
       if (onCheckpoint) {
-        const decision = onCheckpoint({
+        const decision = await onCheckpoint({
           turnIndex: 0,
           toolCount: 1,
           hasToolUse: true,