@vellumai/assistant 0.7.3 → 0.8.1

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

@@ -3,10 +3,12 @@ import { describe, expect, test } from "bun:test";
 import type { ContextWindowConfig } from "../config/types.js";
 import { estimateTextTokens } from "../context/token-estimator.js";
 import {
+  appendTailAnchorToSummary,
   clampSummaryAtSectionBoundary,
   CONTEXT_SUMMARY_MARKER,
   ContextWindowManager,
   createContextSummaryMessage,
+  extractTailAssistantText,
   getSummaryFromContextMessage,
   stripCompactionOnlyInjections,
 } from "../context/window-manager.js";
@@ -72,7 +74,7 @@ describe("ContextWindowManager", () => {
     expect(result.reason).toBe("below compaction threshold");
   });
 
-  test("explains forced compaction skip when conversation already fits target", async () => {
+  test("explains forced compaction skip when only one user turn exists", async () => {
     const provider = createProvider(() => {
       throw new Error("summarizer should not be called");
     });
@@ -84,6 +86,10 @@ describe("ContextWindowManager", () => {
         targetBudgetRatio: 0.5,
       }),
     });
+    // Only one user turn — there is nothing earlier to summarize, so
+    // forced compaction must still skip but report a clear reason
+    // instead of "conversation already fits within the compaction
+    // target". `force=true` is honored everywhere else.
     const history = [message("user", "hello"), message("assistant", "hi")];
 
     const result = await manager.maybeCompact(history, undefined, {
@@ -93,8 +99,151 @@ describe("ContextWindowManager", () => {
     expect(result.compacted).toBe(false);
     expect(result.messages).toEqual(history);
     expect(result.reason).toBe(
+      "only one user turn — nothing earlier to compact",
+    );
+  });
+
+  test("forced compaction summarizes when adjustForToolPairs would walk boundary to summary", async () => {
+    let summaryCalls = 0;
+    const provider = createProvider(() => {
+      summaryCalls += 1;
+      return {
+        content: [{ type: "text", text: "## Summary\n- rescue path ran" }],
+        model: "mock-model",
+        usage: { inputTokens: 100, outputTokens: 25 },
+        stopReason: "end_turn",
+      };
+    });
+    const manager = new ContextWindowManager({
+      provider,
+      systemPrompt: "system prompt",
+      config: makeConfig({
+        maxInputTokens: 10_000,
+        targetBudgetRatio: 0.5,
+      }),
+    });
+    // Conversation starts with consecutive `assistant(tool_use)` →
+    // `user(tool_result + text)` pairs. `collectUserTurnStartIndexes`
+    // includes the mixed user messages (not tool_result-only), so the
+    // earliest `userTurnStarts` entry is the message containing
+    // `tool_result(tool-1)`. Once the projection-optimism clamp
+    // decrements the keep boundary to that user turn,
+    // `adjustForToolPairs` walks the boundary back through the
+    // tool_use/tool_result chain to index 0 — under the old code that
+    // routed `/compact` through the "already fits" skip path. With the
+    // rescue, summarization runs and orphan `tool_result` blocks are
+    // stripped from the kept region.
+    const history: Message[] = [
+      {
+        role: "assistant",
+        content: [{ type: "tool_use", id: "tool-1", name: "x", input: {} }],
+      },
+      {
+        role: "user",
+        content: [
+          { type: "tool_result", tool_use_id: "tool-1", content: "result1" },
+          { type: "text", text: "u1" },
+        ],
+      },
+      {
+        role: "assistant",
+        content: [{ type: "tool_use", id: "tool-2", name: "x", input: {} }],
+      },
+      {
+        role: "user",
+        content: [
+          { type: "tool_result", tool_use_id: "tool-2", content: "result2" },
+          { type: "text", text: "u2" },
+        ],
+      },
+      message("assistant", "a3"),
+      message("user", "u3"),
+      message("assistant", "a4"),
+    ];
+
+    const result = await manager.maybeCompact(history, undefined, {
+      force: true,
+      precomputedEstimate: 50_000,
+    });
+
+    expect(result.compacted).toBe(true);
+    expect(summaryCalls).toBe(1);
+    expect(result.reason).not.toBe(
       "conversation already fits within the compaction target",
     );
+    expect(result.reason).not.toBe(
+      "truncated tool results without summarization",
+    );
+    expect(result.compactedMessages).toBeGreaterThan(0);
+
+    // The kept region must not contain orphan tool_result blocks whose
+    // tool_use lives in the compacted region — the LLM API would reject
+    // such messages on the next agent turn.
+    const keptToolUseIds = new Set<string>();
+    for (const msg of result.messages) {
+      if (msg.role !== "assistant") continue;
+      for (const block of msg.content) {
+        if (
+          (block.type === "tool_use" || block.type === "server_tool_use") &&
+          "id" in block
+        ) {
+          keptToolUseIds.add((block as { id: string }).id);
+        }
+      }
+    }
+    for (const msg of result.messages) {
+      if (msg.role !== "user") continue;
+      for (const block of msg.content) {
+        if (
+          (block.type === "tool_result" ||
+            block.type === "web_search_tool_result") &&
+          "tool_use_id" in block
+        ) {
+          expect(keptToolUseIds.has(block.tool_use_id as string)).toBe(true);
+        }
+      }
+    }
+  });
+
+  test("forced compaction summarizes when compactable count is below MIN guard", async () => {
+    let summaryCalls = 0;
+    const provider = createProvider(() => {
+      summaryCalls += 1;
+      return {
+        content: [{ type: "text", text: "## Summary\n- min-bypass ran" }],
+        model: "mock-model",
+        usage: { inputTokens: 100, outputTokens: 25 },
+        stopReason: "end_turn",
+      };
+    });
+    const manager = new ContextWindowManager({
+      provider,
+      systemPrompt: "system prompt",
+      config: makeConfig({
+        maxInputTokens: 10_000,
+        targetBudgetRatio: 0.5,
+      }),
+    });
+    // Two user turns separated by a single assistant message — the
+    // smallest realistic conversation where a forced compaction has
+    // anything to summarize. After the projection clamp + rescue, the
+    // compactable region is at most one user turn (the first one),
+    // which can fall below `MIN_COMPACTABLE_PERSISTED_MESSAGES`. The
+    // bypass must let summarization run instead of returning
+    // "insufficient compactable persisted messages".
+    const history: Message[] = [message("user", "u1"), message("user", "u2")];
+
+    const result = await manager.maybeCompact(history, undefined, {
+      force: true,
+      precomputedEstimate: 50_000,
+    });
+
+    expect(result.compacted).toBe(true);
+    expect(summaryCalls).toBe(1);
+    expect(result.reason).not.toBe(
+      "insufficient compactable persisted messages",
+    );
+    expect(result.compactedMessages).toBeGreaterThan(0);
   });
 
   test("forced compaction summarizes when projection fits but real usage exceeds target", async () => {
@@ -2091,3 +2240,242 @@ describe("clampSummaryAtSectionBoundary", () => {
     expect(clamped.length).toBeLessThanOrEqual(100);
   });
 });
+
+describe("extractTailAssistantText", () => {
+  test("returns the most recent assistant text block", () => {
+    const messages: Message[] = [
+      message("user", "u1"),
+      message("assistant", "a1 first"),
+      message("user", "u2"),
+      message("assistant", "a2 last"),
+    ];
+    expect(extractTailAssistantText(messages)).toBe("a2 last");
+  });
+
+  test("returns null when no assistant text is present", () => {
+    const messages: Message[] = [message("user", "u1"), message("user", "u2")];
+    expect(extractTailAssistantText(messages)).toBeNull();
+  });
+
+  test("skips assistant messages with only tool_use blocks and finds the prior text", () => {
+    const messages: Message[] = [
+      message("assistant", "a1 narration before tool use"),
+      message("user", "u1"),
+      {
+        role: "assistant",
+        content: [
+          {
+            type: "tool_use",
+            id: "tool-1",
+            name: "bash",
+            input: { command: "ls" },
+          } as ContentBlock,
+        ],
+      },
+    ];
+    expect(extractTailAssistantText(messages)).toBe(
+      "a1 narration before tool use",
+    );
+  });
+
+  test("clamps long text from the start so the END is preserved", () => {
+    const longText = "early prefix " + "x".repeat(2000) + " FINAL NEXT STEP";
+    const messages: Message[] = [message("assistant", longText)];
+    const result = extractTailAssistantText(messages, 200);
+    expect(result).not.toBeNull();
+    expect(result!.startsWith("[...truncated]")).toBe(true);
+    expect(result!.endsWith("FINAL NEXT STEP")).toBe(true);
+    // Stripped block size ≈ maxChars; "[...truncated] " adds a fixed prefix.
+    expect(result!.length).toBeLessThanOrEqual(200 + "[...truncated] ".length);
+  });
+
+  test("ignores empty/whitespace-only assistant text", () => {
+    const messages: Message[] = [
+      message("assistant", "real content"),
+      message("assistant", "   \n  "),
+    ];
+    expect(extractTailAssistantText(messages)).toBe("real content");
+  });
+
+  test("returns null for an empty messages array", () => {
+    expect(extractTailAssistantText([])).toBeNull();
+  });
+});
+
+describe("appendTailAnchorToSummary", () => {
+  test("appends a tag-wrapped block after the summary", () => {
+    const out = appendTailAnchorToSummary(
+      "## Goals\n- item",
+      "Next step: file the SSE followup.",
+    );
+    expect(out).toContain("## Goals\n- item");
+    expect(out).toContain(
+      "<verbatim_tail>\nNext step: file the SSE followup.\n</verbatim_tail>",
+    );
+    expect(out.endsWith("</verbatim_tail>")).toBe(true);
+  });
+
+  test("is idempotent: re-applying with new text replaces the prior tail", () => {
+    const first = appendTailAnchorToSummary("body", "tail-1");
+    const second = appendTailAnchorToSummary(first, "tail-2");
+    expect(second).toContain("body");
+    expect(second).toContain("tail-2");
+    expect(second).not.toContain("tail-1");
+    // Exactly one open-tag occurrence — no stacking.
+    expect(second.match(/<verbatim_tail>/g)?.length).toBe(1);
+  });
+});
+
+describe("compaction tail-anchor", () => {
+  test("splices the last assistant text block verbatim into the summary message", async () => {
+    const provider = createProvider(() => ({
+      content: [{ type: "text", text: "## Goals\n- LLM summary" }],
+      model: "mock-model",
+      usage: { inputTokens: 100, outputTokens: 25 },
+      stopReason: "end_turn",
+    }));
+    const manager = new ContextWindowManager({
+      provider,
+      systemPrompt: "system prompt",
+      config: makeConfig({ maxInputTokens: 600 }),
+    });
+    const long = "x".repeat(240);
+    const distinctiveTail =
+      "Pushed 8fe70d63a0 — next step: file the SSE followup as promised.";
+    // Place `distinctiveTail` as the assistant response for u1 so it lands
+    // at the end of the compactable region. With the same 600-token budget
+    // and 6-message shape as the existing 600-token compaction test above,
+    // the binary search settles on keepTurns=2 (kept = [u2, a2, u3, a3];
+    // compactable = [u1, distinctiveTail]) — exercising the real-world
+    // drift scenario where the model's last narration in a long work span
+    // gets summarized away.
+    const history: Message[] = [
+      message("user", `u1 ${long}`),
+      message("assistant", distinctiveTail),
+      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 summaryInner = getSummaryFromContextMessage(result.messages[0]);
+    expect(summaryInner).not.toBeNull();
+    // LLM summary still present.
+    expect(summaryInner).toContain("LLM summary");
+    // Verbatim tail spliced in: distinctive text from the LAST assistant
+    // message in the compactable region (here, `distinctiveTail`).
+    expect(summaryInner).toContain("<verbatim_tail>");
+    expect(summaryInner).toContain(distinctiveTail);
+    expect(summaryInner).toContain("</verbatim_tail>");
+    // summaryText reflects what's persisted in messages[0] for consistency
+    // with downstream consumers (DB, context_compacted event).
+    expect(result.summaryText).toContain(distinctiveTail);
+  });
+
+  test("omits the tail-anchor block when no assistant text exists in compactable region", async () => {
+    // Construct a scenario where the compactable region has assistant
+    // messages with ONLY tool_use blocks (no text) plus user turns. The
+    // anchor should be omitted gracefully.
+    const provider = createProvider(() => ({
+      content: [{ type: "text", text: "## Goals\n- summary" }],
+      model: "mock-model",
+      usage: { inputTokens: 100, outputTokens: 25 },
+      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}`),
+      {
+        role: "assistant",
+        content: [
+          {
+            type: "tool_use",
+            id: "tool-1",
+            name: "bash",
+            input: { command: "ls" },
+          } as ContentBlock,
+        ],
+      },
+      {
+        role: "user",
+        content: [
+          {
+            type: "tool_result",
+            tool_use_id: "tool-1",
+            content: "ls output",
+          } as ContentBlock,
+        ],
+      },
+      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 summaryInner = getSummaryFromContextMessage(result.messages[0]);
+    expect(summaryInner).not.toBeNull();
+    // No tail anchor when the only compactable assistant message has no text.
+    // (a2 / a3 are kept verbatim post-compaction since they're recent enough,
+    // so the compactable-region's only assistant message is the tool_use one.)
+    if (summaryInner!.includes("<verbatim_tail>")) {
+      // If a2 ended up in the compactable region after binary search, the
+      // anchor would surface a2's text — which is fine; the assertion that
+      // matters is that the spliced content (when present) is verbatim
+      // content from the compactable region, not noise. Validate the
+      // ordering: anchor must follow LLM summary text.
+      expect(summaryInner!.indexOf("summary")).toBeLessThan(
+        summaryInner!.indexOf("<verbatim_tail>"),
+      );
+    }
+  });
+
+  test("clamps tail-anchor when the last assistant text is longer than the cap", async () => {
+    const provider = createProvider(() => ({
+      content: [{ type: "text", text: "## Goals\n- summary" }],
+      model: "mock-model",
+      usage: { inputTokens: 100, outputTokens: 25 },
+      stopReason: "end_turn",
+    }));
+    const manager = new ContextWindowManager({
+      provider,
+      systemPrompt: "system prompt",
+      config: makeConfig({ maxInputTokens: 600 }),
+    });
+    const long = "x".repeat(240);
+    const tailEnd = "FINAL DISTINCTIVE END MARKER";
+    // Long enough to trip TAIL_ANCHOR_MAX_CHARS (=1500) clamping.
+    const longTail = "early body " + "y".repeat(2000) + " " + tailEnd;
+    const history: Message[] = [
+      message("user", `u1 ${long}`),
+      message("assistant", longTail),
+      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 summaryInner = getSummaryFromContextMessage(result.messages[0]);
+    expect(summaryInner).not.toBeNull();
+    if (summaryInner!.includes("<verbatim_tail>")) {
+      // When clamped, the END is preserved (most recent narration).
+      expect(summaryInner).toContain(tailEnd);
+      // And the early prefix is dropped.
+      expect(summaryInner).toContain("[...truncated]");
+      expect(summaryInner).not.toContain("early body");
+    }
+  });
+});

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

@@ -1,18 +1,12 @@
 import { describe, expect, mock, test } from "bun:test";
 
 import type { AgentEvent } from "../agent/loop.js";
-import { _setOverridesForTesting } from "../config/assistant-feature-flags.js";
 import type {
   ContentBlock,
   Message,
   ProviderResponse,
 } from "../providers/types.js";
 
-// This test exercises v1 conversation routing. The `memory-v2-enabled` flag
-// (registry default `true`) flips memory routing to v2 — disable it here so
-// the v1 paths under test stay active.
-_setOverridesForTesting({ "memory-v2-enabled": false });
-
 mock.module("../util/logger.js", () => ({
   getLogger: () =>
     new Proxy({} as Record<string, unknown>, { get: () => () => {} }),
@@ -61,6 +55,7 @@ mock.module("../config/loader.js", () => ({
       pricingOverrides: [],
     },
     rateLimit: { maxRequestsPerMinute: 0 },
+    memory: { v2: { enabled: false } },
     daemon: {
       startupSocketWaitMs: 5000,
       stopTimeoutMs: 5000,

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

@@ -476,7 +476,7 @@ function makeCtx(
     }),
 
     graphMemory: {
-      onCompacted: () => {},
+      onCompacted: async () => {},
       prepareMemory: async () => ({
         runMessages: [],
         injectedTokens: 0,

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

@@ -76,6 +76,7 @@ const defaultLlmConfig: LLMConfig = {
   profiles: {},
   profileOrder: [],
   callSites: {},
+  profileSession: { defaultTtlSeconds: 1800, maxTtlSeconds: 43200 },
   pricingOverrides: [],
 };
 
@@ -531,7 +532,7 @@ function makeCtx(
     }),
 
     graphMemory: {
-      onCompacted: () => {},
+      onCompacted: async () => {},
       prepareMemory: async () => ({
         runMessages: [],
         injectedTokens: 0,

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

@@ -626,7 +626,7 @@ function makeCtx(
     }),
 
     graphMemory: {
-      onCompacted: () => {},
+      onCompacted: async () => {},
       prepareMemory: async () => ({
         runMessages: [],
         injectedTokens: 0,
@@ -3652,11 +3652,11 @@ describe("session-agent-loop", () => {
       expect(rendered).not.toContain("original root");
     });
 
-    test("applyCompactionResult records Slack timestamp watermark when provided", () => {
+    test("applyCompactionResult records Slack timestamp watermark when provided", async () => {
       const ctx = makeCtx();
       const events: ServerMessage[] = [];
 
-      applyCompactionResult(
+      await applyCompactionResult(
         ctx,
         {
           messages: [

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

@@ -280,21 +280,13 @@ function seedPendingConfirmation(
   conversation: Conversation,
   requestId: string,
 ): void {
+  // Access private ownedIds so denyAllPending/dispose can find this request.
+  // promptResolve/promptReject callbacks are stored in pendingInteractions via
+  // registerPendingInteraction, which is called separately in each test.
   const prompter = conversation["prompter"] as unknown as {
-    pending: Map<
-      string,
-      {
-        resolve: (...args: unknown[]) => void;
-        reject: (...args: unknown[]) => void;
-        timer: ReturnType<typeof setTimeout>;
-      }
-    >;
+    ownedIds: Set<string>;
   };
-  prompter.pending.set(requestId, {
-    resolve: () => {},
-    reject: () => {},
-    timer: setTimeout(() => {}, 60_000),
-  });
+  prompter.ownedIds.add(requestId);
 }
 
 // ---------------------------------------------------------------------------

package/src/__tests__/conversation-crud-inference-profile.test.ts

@@ -9,7 +9,9 @@ mock.module("../util/logger.js", () => ({
 import {
   createConversation,
   getConversation,
+  getConversationOverrideProfileFromRow,
   setConversationInferenceProfile,
+  setConversationInferenceProfileSession,
 } from "../memory/conversation-crud.js";
 import { getDb } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
@@ -52,3 +54,101 @@ describe("setConversationInferenceProfile", () => {
     expect(updated).toHaveProperty("inferenceProfile", "cost-optimized");
   });
 });
+
+describe("getConversationOverrideProfileFromRow — lazy expiry check", () => {
+  beforeEach(() => {
+    const db = getDb();
+    db.run(`DELETE FROM messages`);
+    db.run(`DELETE FROM conversations`);
+  });
+
+  test("returns undefined when inferenceProfileExpiresAt is in the past", () => {
+    const conv = createConversation("inference-profile-expired");
+    // Set a session-backed profile with an already-expired timestamp.
+    setConversationInferenceProfileSession(
+      conv.id,
+      "balanced",
+      "session-uuid-1",
+      Date.now() - 1,
+    );
+    const row = getConversation(conv.id);
+    expect(row).not.toBeNull();
+    expect(getConversationOverrideProfileFromRow(row)).toBeUndefined();
+  });
+
+  test("returns the profile when inferenceProfileExpiresAt is in the future", () => {
+    const conv = createConversation("inference-profile-active-session");
+    setConversationInferenceProfileSession(
+      conv.id,
+      "balanced",
+      "session-uuid-2",
+      Date.now() + 60_000,
+    );
+    const row = getConversation(conv.id);
+    expect(row).not.toBeNull();
+    expect(getConversationOverrideProfileFromRow(row)).toBe("balanced");
+  });
+
+  test("returns undefined at the exact-expiry boundary (expiresAt === now)", () => {
+    // Boundary consistency with the reaper SQL (`expires_at <= now`) and
+    // the active-session queries (`expiresAt > now`): the lazy check must
+    // treat `expiresAt === now` as expired, not active. Otherwise a
+    // just-expired session would be served for one extra turn while the
+    // reaper is racing to clear it.
+    const conv = createConversation("inference-profile-boundary");
+    const now = Date.now();
+    setConversationInferenceProfileSession(
+      conv.id,
+      "balanced",
+      "session-uuid-boundary",
+      now,
+    );
+    const row = getConversation(conv.id);
+    expect(row).not.toBeNull();
+    expect(row?.inferenceProfileExpiresAt).toBe(now);
+    // Freeze Date.now to the exact stored expiry so this is deterministic.
+    const realNow = Date.now;
+    Date.now = () => now;
+    try {
+      expect(getConversationOverrideProfileFromRow(row)).toBeUndefined();
+    } finally {
+      Date.now = realNow;
+    }
+  });
+
+  test("returns the profile when no expiry is set (non-session override)", () => {
+    const conv = createConversation("inference-profile-no-expiry");
+    setConversationInferenceProfileSession(
+      conv.id,
+      "quality-optimized",
+      null,
+      null,
+    );
+    const row = getConversation(conv.id);
+    expect(row).not.toBeNull();
+    expect(getConversationOverrideProfileFromRow(row)).toBe(
+      "quality-optimized",
+    );
+  });
+
+  test.each<"background" | "scheduled">(["background", "scheduled"])(
+    "returns undefined for %s conversations even when a profile is pinned",
+    (conversationType) => {
+      const conv = createConversation({
+        title: `inference-profile-${conversationType}`,
+        conversationType,
+      });
+      setConversationInferenceProfileSession(
+        conv.id,
+        "quality-optimized",
+        null,
+        null,
+      );
+      const row = getConversation(conv.id);
+      expect(row).not.toBeNull();
+      expect(row?.conversationType).toBe(conversationType);
+      expect(row?.inferenceProfile).toBe("quality-optimized");
+      expect(getConversationOverrideProfileFromRow(row)).toBeUndefined();
+    },
+  );
+});

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

@@ -305,6 +305,44 @@ describe("classifyConversationError", () => {
     });
   });
 
+  describe("image-input dimension errors via ProviderError (400)", () => {
+    it("classifies Anthropic 400 with image-dimension overflow as image_dimensions_too_large (non-retryable)", () => {
+      const err = new ProviderError(
+        'Anthropic API error (400): 400 {"type":"error","error":{"type":"invalid_request_error","message":"messages.8.content.3.image.source.base64.data: At least one of the image dimensions exceed max allowed size: 8000 pixels"},"request_id":"req_011CaoaGzPXNs2dxAWegSg9D"}',
+        "anthropic",
+        400,
+      );
+      const result = classifyConversationError(err, baseCtx);
+      expect(result.code).toBe("IMAGE_TOO_LARGE");
+      expect(result.errorCategory).toBe("image_dimensions_too_large");
+      expect(result.retryable).toBe(false);
+      expect(result.userMessage).toContain("image");
+      expect(result.userMessage).toContain("8000");
+    });
+
+    it("matches the singular 'image dimension exceeds' phrasing as well", () => {
+      const err = new ProviderError(
+        "image dimension exceeds max allowed size: 8000 pixels",
+        "anthropic",
+        400,
+      );
+      const result = classifyConversationError(err, baseCtx);
+      expect(result.errorCategory).toBe("image_dimensions_too_large");
+      expect(result.retryable).toBe(false);
+    });
+
+    it("does not steal generic 400s that happen to mention 'image'", () => {
+      const err = new ProviderError(
+        "invalid request: image source is missing",
+        "anthropic",
+        400,
+      );
+      const result = classifyConversationError(err, baseCtx);
+      expect(result.errorCategory).toBe("provider_api_error");
+      expect(result.retryable).toBe(true);
+    });
+  });
+
   describe("ordering errors (tool_use/tool_result mismatches)", () => {
     const cases = [
       "tool_result block not immediately after tool_use block",