@vellumai/assistant 0.6.4 → 0.6.6

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

@@ -3,15 +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(
@@ -36,9 +40,10 @@ function makeConfig(
 
 function createProvider(
   fn: (messages: Message[]) => ProviderResponse | Promise<ProviderResponse>,
+  name: string = "mock",
 ): Provider {
   return {
-    name: "mock",
+    name,
     async sendMessage(messages: Message[]): Promise<ProviderResponse> {
       return fn(messages);
     },
@@ -242,6 +247,63 @@ describe("ContextWindowManager", () => {
     expect(result.summaryText).toContain("## Recent Progress");
   });
 
+  test("marks summaryFailed when the provider throws and fallback runs", async () => {
+    // The agent-loop circuit breaker distinguishes "LLM call failed but
+    // fallback rescued us" from "compaction succeeded end-to-end". The
+    // fallback path must set summaryFailed:true so callers can count
+    // consecutive failures without losing the compacted messages.
+    const provider = createProvider(async () => {
+      throw new Error("provider unavailable");
+    });
+    const manager = new ContextWindowManager({
+      provider,
+      systemPrompt: "system prompt",
+      config: makeConfig({
+        maxInputTokens: 260,
+        targetBudgetRatio: 0.59,
+      }),
+    });
+    const long = "z".repeat(220);
+    const history = [
+      message("user", `task ${long}`),
+      message("assistant", `result ${long}`),
+      message("user", `followup ${long}`),
+    ];
+
+    const result = await manager.maybeCompact(history);
+    expect(result.compacted).toBe(true);
+    expect(result.summaryFailed).toBe(true);
+  });
+
+  test("does not mark summaryFailed on a successful provider call", async () => {
+    const provider = createProvider(() => ({
+      content: [
+        { type: "text", text: "## Goals\n- summary produced by provider" },
+      ],
+      model: "mock-model",
+      usage: { inputTokens: 60, outputTokens: 12 },
+      stopReason: "end_turn",
+    }));
+    const manager = new ContextWindowManager({
+      provider,
+      systemPrompt: "system prompt",
+      config: makeConfig({
+        maxInputTokens: 260,
+        targetBudgetRatio: 0.59,
+      }),
+    });
+    const long = "z".repeat(220);
+    const history = [
+      message("user", `task ${long}`),
+      message("assistant", `result ${long}`),
+      message("user", `followup ${long}`),
+    ];
+
+    const result = await manager.maybeCompact(history);
+    expect(result.compacted).toBe(true);
+    expect(result.summaryFailed).toBe(false);
+  });
+
   test("serializes file blocks for summary chunks", async () => {
     const prompts: string[] = [];
     const provider = createProvider((messages) => {
@@ -261,11 +323,12 @@ describe("ContextWindowManager", () => {
       provider,
       systemPrompt: "system prompt",
       config: makeConfig({
-        maxInputTokens: 550,
-        targetBudgetRatio: 0.59,
+        maxInputTokens: 2000,
+        targetBudgetRatio: 0.4,
+        compactThreshold: 0.35,
       }),
     });
-    const long = "f".repeat(500);
+    const long = "f".repeat(1500);
     const history: Message[] = [
       {
         role: "user",
@@ -834,6 +897,143 @@ describe("ContextWindowManager", () => {
     );
   });
 
+  test("force compaction with loose target override still summarizes persisted messages", async () => {
+    // `pickKeepBoundary` clamps `targetInputTokensOverride` to
+    // `config.targetInputTokens`, so a loose override cannot
+    // short-circuit summarization into the truncate-only early-exit.
+
+    let summaryCalls = 0;
+    const provider = createProvider(() => {
+      summaryCalls += 1;
+      return {
+        content: [{ type: "text", text: "## Goals\n- real summary" }],
+        model: "mock-model",
+        usage: { inputTokens: 80, outputTokens: 20 },
+        stopReason: "end_turn",
+      };
+    });
+
+    // Scaled from prod (max 200k → 1000) preserving key ratios: the
+    // loose override (~0.85×max) is ~17× the post-compaction target
+    // (~0.05×max), so history between the two exercises the clamp.
+    const manager = new ContextWindowManager({
+      provider,
+      systemPrompt: "system prompt",
+      config: makeConfig({
+        maxInputTokens: 1000,
+        targetBudgetRatio: 0.1,
+        summaryBudgetRatio: 0.05,
+        compactThreshold: 0.3,
+      }),
+    });
+
+    // History in the "no-op zone": above threshold (300), below override (850).
+    const long = "x".repeat(180);
+    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}`),
+      message("user", `u4 ${long}`),
+      message("assistant", `a4 ${long}`),
+      message("user", `u5 ${long}`),
+    ];
+
+    const preflightBudgetAnalog = Math.floor(1000 * 0.85);
+    const result = await manager.maybeCompact(history, undefined, {
+      force: true,
+      targetInputTokensOverride: preflightBudgetAnalog,
+    });
+
+    // Guard: we're actually above the compact threshold.
+    expect(result.previousEstimatedInputTokens).toBeGreaterThan(
+      result.thresholdTokens,
+    );
+
+    // A real summarization happened (not the truncate-only no-op).
+    expect(result.compactedPersistedMessages).toBeGreaterThan(0);
+    expect(summaryCalls).toBeGreaterThan(0);
+  });
+
+  test("force=true compacts below minFloor when a kept turn exceeds target", async () => {
+    // A giant paste in the last user turn means minFloor=1 alone exceeds target.
+    // Under force, pickKeepBoundary should walk keepTurns below minFloor (down to
+    // 0) so the huge block falls into the compacted region and gets summarized
+    // instead of being kept at full size.
+    const provider = createProvider(() => ({
+      content: [{ type: "text", text: "## Goals\n- compressed large paste" }],
+      model: "mock-model",
+      usage: { inputTokens: 120, outputTokens: 20 },
+      stopReason: "end_turn",
+    }));
+    const manager = new ContextWindowManager({
+      provider,
+      systemPrompt: "system prompt",
+      config: makeConfig({ maxInputTokens: 600, targetBudgetRatio: 0.2 }),
+    });
+    const hugePaste = "p".repeat(4000); // ~1000 tokens, well above targetInputTokens
+    const history: Message[] = [
+      message("user", "u1 small"),
+      message("assistant", "a1 small"),
+      message("user", `u2 ${hugePaste}`),
+    ];
+
+    const result = await manager.maybeCompact(history, undefined, {
+      force: true,
+    });
+
+    expect(result.compacted).toBe(true);
+    // With force=true the kept region is empty; all turns including the oversized
+    // paste were summarized, so the compacted result is just the summary.
+    expect(result.messages).toHaveLength(1);
+    expect(result.compactedMessages).toBe(history.length);
+    expect(getSummaryFromContextMessage(result.messages[0])).toContain(
+      "compressed large paste",
+    );
+    expect(result.estimatedInputTokens).toBeLessThan(
+      result.previousEstimatedInputTokens,
+    );
+  });
+
+  test("force=false honors minFloor even when the kept turn exceeds target", async () => {
+    // Same oversized paste, but without force the algorithm must preserve the
+    // minFloor=1 recent turn (auto mid-loop compaction needs the in-flight turn
+    // intact). Anything compactable before the floor still gets summarized.
+    const provider = createProvider(() => ({
+      content: [{ type: "text", text: "## Goals\n- summary" }],
+      model: "mock-model",
+      usage: { inputTokens: 60, outputTokens: 10 },
+      stopReason: "end_turn",
+    }));
+    const manager = new ContextWindowManager({
+      provider,
+      systemPrompt: "system prompt",
+      config: makeConfig({ maxInputTokens: 600, targetBudgetRatio: 0.2 }),
+    });
+    const hugePaste = "p".repeat(4000);
+    const history: Message[] = [
+      message("user", "u1 small"),
+      message("assistant", "a1 small"),
+      message("user", "u2 small"),
+      message("assistant", "a2 small"),
+      message("user", `u3 ${hugePaste}`),
+    ];
+
+    const result = await manager.maybeCompact(history);
+
+    expect(result.compacted).toBe(true);
+    // The oversized last user turn is retained verbatim; the kept array starts
+    // with the summary followed by the messages from that turn onward.
+    const lastUser = result.messages
+      .filter((m) => m.role === "user")
+      .map((m) => (m.content[0].type === "text" ? m.content[0].text : ""))
+      .find((t) => t.startsWith("u3 "));
+    expect(lastUser).toBeDefined();
+    expect(lastUser!.length).toBeGreaterThan(hugePaste.length);
+  });
+
   test("shouldCompact returns needed=false with estimatedTokens when below threshold", () => {
     const provider = createProvider(() => {
       throw new Error("should not be called");
@@ -1096,6 +1296,197 @@ describe("ContextWindowManager", () => {
     expect(manager.nonPersistedPrefixCount).toBe(0);
   });
 
+  test("summary system prompt instructs verbatim thread-anchor preservation", async () => {
+    const capturedSystemPrompts: (string | undefined)[] = [];
+    const provider: Provider = {
+      name: "mock",
+      async sendMessage(
+        _messages: Message[],
+        _tools,
+        systemPrompt,
+      ): Promise<ProviderResponse> {
+        capturedSystemPrompts.push(systemPrompt);
+        return {
+          content: [
+            {
+              type: "text",
+              text: "## Goals\n- preserved thread parent verbatim",
+            },
+          ],
+          model: "mock-model",
+          usage: { inputTokens: 60, outputTokens: 12 },
+          stopReason: "end_turn",
+        };
+      },
+    };
+    const manager = new ContextWindowManager({
+      provider,
+      systemPrompt: "system prompt",
+      config: makeConfig({ maxInputTokens: 600 }),
+    });
+    const long = "x".repeat(240);
+    // Simulate a Slack-style transcript where an old user "thread parent"
+    // message is about to be compacted while a later reply survives in the
+    // retained tail. The clause being asserted instructs the summarizer to
+    // preserve that parent verbatim — we cannot verify the model's behavior
+    // here (the provider is a stub), so we instead assert the clause itself
+    // reaches the summarizer.
+    const history: Message[] = [
+      message("user", `parent: kickoff plan ${long}`),
+      message("assistant", `a1 ${long}`),
+      message("user", `u2 ${long}`),
+      message("assistant", `a2 ${long}`),
+      message("user", `reply-in-thread ${long}`),
+      message("assistant", `a3 ${long}`),
+    ];
+
+    const result = await manager.maybeCompact(history);
+    expect(result.compacted).toBe(true);
+    expect(capturedSystemPrompts.length).toBeGreaterThan(0);
+    const seenPrompt = capturedSystemPrompts[0];
+    expect(seenPrompt).toBeDefined();
+    expect(seenPrompt).toContain("Thread anchors");
+    expect(seenPrompt).toContain("verbatim");
+  });
+
+  test("summary prompt lists retained-tail thread-reply references", async () => {
+    const capturedMessages: Message[][] = [];
+    const provider: Provider = {
+      name: "mock",
+      async sendMessage(messages: Message[]): Promise<ProviderResponse> {
+        capturedMessages.push(messages);
+        return {
+          content: [{ type: "text", text: "## Goals\n- ok" }],
+          model: "mock-model",
+          usage: { inputTokens: 60, outputTokens: 12 },
+          stopReason: "end_turn",
+        };
+      },
+    };
+    const manager = new ContextWindowManager({
+      provider,
+      systemPrompt: "system prompt",
+      config: makeConfig({ maxInputTokens: 600 }),
+    });
+    const long = "x".repeat(240);
+    // Compactable region ends before the retained tail, which contains a
+    // Slack-style reply line that cites its parent via `→ M1a2b3c`. The
+    // summary prompt must surface that reference so the Thread-anchors
+    // instruction has something to act on.
+    const history: Message[] = [
+      message("user", `[11/14/23 14:25 @alice]: parent kickoff ${long}`),
+      message("assistant", `a1 ${long}`),
+      message("user", `u2 ${long}`),
+      message("assistant", `a2 ${long}`),
+      message("user", `[11/14/23 14:28 @bob → M1a2b3c]: reply ${long}`),
+      message("assistant", `a3 ${long}`),
+    ];
+
+    const result = await manager.maybeCompact(history);
+    expect(result.compacted).toBe(true);
+    expect(capturedMessages.length).toBeGreaterThan(0);
+    const userPromptText = capturedMessages[0]
+      .flatMap((m) => m.content)
+      .filter(
+        (b): b is Extract<ContentBlock, { type: "text" }> => b.type === "text",
+      )
+      .map((b) => b.text)
+      .join("\n");
+    expect(userPromptText).toContain("### Retained Thread References");
+    expect(userPromptText).toContain("→ M1a2b3c");
+  });
+
+  test("summary prompt lists retained-tail thread-reply references for edited replies", async () => {
+    const capturedMessages: Message[][] = [];
+    const provider: Provider = {
+      name: "mock",
+      async sendMessage(messages: Message[]): Promise<ProviderResponse> {
+        capturedMessages.push(messages);
+        return {
+          content: [{ type: "text", text: "## Goals\n- ok" }],
+          model: "mock-model",
+          usage: { inputTokens: 60, outputTokens: 12 },
+          stopReason: "end_turn",
+        };
+      },
+    };
+    const manager = new ContextWindowManager({
+      provider,
+      systemPrompt: "system prompt",
+      config: makeConfig({ maxInputTokens: 600 }),
+    });
+    const long = "x".repeat(240);
+    // An edited reply renders with `, edited …` between the parent alias and
+    // the closing bracket: `→ Mxxxxxx, edited MM/DD/YY HH:MM]`. The regex
+    // must still flag these lines so retention works for edited replies.
+    const history: Message[] = [
+      message("user", `[11/14/23 14:25 @alice]: parent kickoff ${long}`),
+      message("assistant", `a1 ${long}`),
+      message("user", `u2 ${long}`),
+      message("assistant", `a2 ${long}`),
+      message(
+        "user",
+        `[11/14/23 14:28 @bob → M1a2b3c, edited 11/14/23 14:32]: reply ${long}`,
+      ),
+      message("assistant", `a3 ${long}`),
+    ];
+
+    const result = await manager.maybeCompact(history);
+    expect(result.compacted).toBe(true);
+    expect(capturedMessages.length).toBeGreaterThan(0);
+    const userPromptText = capturedMessages[0]
+      .flatMap((m) => m.content)
+      .filter(
+        (b): b is Extract<ContentBlock, { type: "text" }> => b.type === "text",
+      )
+      .map((b) => b.text)
+      .join("\n");
+    expect(userPromptText).toContain("### Retained Thread References");
+    expect(userPromptText).toContain("→ M1a2b3c, edited 11/14/23 14:32");
+  });
+
+  test("summary prompt omits retained references when retained tail has no thread markers", async () => {
+    const capturedMessages: Message[][] = [];
+    const provider: Provider = {
+      name: "mock",
+      async sendMessage(messages: Message[]): Promise<ProviderResponse> {
+        capturedMessages.push(messages);
+        return {
+          content: [{ type: "text", text: "## Goals\n- ok" }],
+          model: "mock-model",
+          usage: { inputTokens: 60, outputTokens: 12 },
+          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);
+    const userPromptText = capturedMessages[0]
+      .flatMap((m) => m.content)
+      .filter(
+        (b): b is Extract<ContentBlock, { type: "text" }> => b.type === "text",
+      )
+      .map((b) => b.text)
+      .join("\n");
+    expect(userPromptText).not.toContain("### Retained Thread References");
+    expect(userPromptText).not.toMatch(/→ M[0-9a-f]{6}]/);
+  });
+
   test("does not subtract summaryOffset when summary at index 0 is child-owned from prior compaction", async () => {
     const provider = createProvider(() => ({
       content: [{ type: "text", text: "## Goals\n- next child summary" }],
@@ -1140,4 +1531,492 @@ describe("ContextWindowManager", () => {
     expect(result.compactedPersistedMessages).toBe(2);
     expect(manager.nonPersistedPrefixCount).toBe(0);
   });
+
+  test("Slack origin bumps default minKeepRecentUserTurns to 8", async () => {
+    const provider = createProvider(() => ({
+      content: [{ type: "text", text: "## Goals\n- slack thread context" }],
+      model: "mock-model",
+      usage: { inputTokens: 60, outputTokens: 12 },
+      stopReason: "end_turn",
+    }));
+
+    // Use targetInputTokensOverride so the binary search is forced even
+    // for a small history. Both managers see the same tight budget; the
+    // only knob that varies is conversationOriginChannel.
+    const config = makeConfig({ maxInputTokens: 12_000 });
+    const long = "s".repeat(220);
+    // 9 user turns: enough headroom for Slack's bumped floor of 8 to be
+    // distinguishable from the default floor of 1.
+    const history: Message[] = [];
+    for (let i = 1; i <= 9; i++) {
+      history.push(message("user", `u${i} ${long}`));
+      history.push(message("assistant", `a${i} ${long}`));
+    }
+
+    const slackManager = new ContextWindowManager({
+      provider,
+      systemPrompt: "system prompt",
+      config,
+    });
+    const slackResult = await slackManager.maybeCompact(history, undefined, {
+      force: true,
+      targetInputTokensOverride: 200,
+      conversationOriginChannel: "slack",
+    });
+
+    const defaultManager = new ContextWindowManager({
+      provider,
+      systemPrompt: "system prompt",
+      config,
+    });
+    const defaultResult = await defaultManager.maybeCompact(
+      history,
+      undefined,
+      { force: true, targetInputTokensOverride: 200 },
+    );
+
+    expect(slackResult.compacted).toBe(true);
+    expect(defaultResult.compacted).toBe(true);
+    // Default floor (1 user turn) compacts more of the history than the
+    // Slack floor (8 user turns), which preserves more recent context.
+    expect(defaultResult.compactedMessages).toBeGreaterThan(
+      slackResult.compactedMessages,
+    );
+    // Slack keeps 8 of 9 user turns: 16 kept messages, 2 compacted.
+    expect(slackResult.compactedMessages).toBe(2);
+  });
+
+  test("non-Slack origin keeps default minKeepRecentUserTurns of 1", async () => {
+    const provider = createProvider(() => ({
+      content: [{ type: "text", text: "## Goals\n- standard summary" }],
+      model: "mock-model",
+      usage: { inputTokens: 60, outputTokens: 12 },
+      stopReason: "end_turn",
+    }));
+
+    const config = makeConfig({ maxInputTokens: 12_000 });
+    const long = "n".repeat(220);
+    const history: Message[] = [];
+    for (let i = 1; i <= 9; i++) {
+      history.push(message("user", `u${i} ${long}`));
+      history.push(message("assistant", `a${i} ${long}`));
+    }
+
+    // Telegram origin must behave identically to no-channel-hint default.
+    const telegramManager = new ContextWindowManager({
+      provider,
+      systemPrompt: "system prompt",
+      config,
+    });
+    const telegramResult = await telegramManager.maybeCompact(
+      history,
+      undefined,
+      {
+        force: true,
+        targetInputTokensOverride: 200,
+        conversationOriginChannel: "telegram",
+      },
+    );
+
+    const defaultManager = new ContextWindowManager({
+      provider,
+      systemPrompt: "system prompt",
+      config,
+    });
+    const defaultResult = await defaultManager.maybeCompact(
+      history,
+      undefined,
+      { force: true, targetInputTokensOverride: 200 },
+    );
+
+    expect(telegramResult.compacted).toBe(true);
+    expect(defaultResult.compacted).toBe(true);
+    expect(telegramResult.compactedMessages).toBe(
+      defaultResult.compactedMessages,
+    );
+  });
+
+  test("explicit minKeepRecentUserTurns wins over Slack default", async () => {
+    const provider = createProvider(() => ({
+      content: [{ type: "text", text: "## Goals\n- emergency override" }],
+      model: "mock-model",
+      usage: { inputTokens: 60, outputTokens: 12 },
+      stopReason: "end_turn",
+    }));
+
+    const manager = new ContextWindowManager({
+      provider,
+      systemPrompt: "system prompt",
+      config: makeConfig({
+        maxInputTokens: 260,
+        targetBudgetRatio: 0.28,
+      }),
+    });
+    const long = "e".repeat(220);
+    const history: Message[] = [
+      message("user", `u1 ${long}`),
+      message("assistant", `a1 ${long}`),
+      message("user", `u2 ${long}`),
+    ];
+
+    // Emergency override (`minKeepRecentUserTurns: 0`) must take precedence
+    // over the Slack-bumped default of 8 — this guards the agent loop's
+    // context-too-large recovery path which always passes 0.
+    const result = await manager.maybeCompact(history, undefined, {
+      force: true,
+      minKeepRecentUserTurns: 0,
+      conversationOriginChannel: "slack",
+    });
+    expect(result.compacted).toBe(true);
+    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);
+  });
 });