@vellumai/assistant 0.11.4 → 0.11.5-dev.202608220019.a778cf0

package/src/__tests__/config-loader-backfill.test.ts

@@ -49,6 +49,7 @@ afterAll(() => {
 });
 
 import {
+  CODE_DEFAULT_PROFILE_ENTRIES,
   getEffectiveProfile,
   getEffectiveProfiles,
   getEffectiveProfilesForProvider,
@@ -164,6 +165,14 @@ const LEGACY_HATCH_PROFILE_NAMES = [
   "custom-cost-optimized",
 ] as const;
 
+/**
+ * The managed Balanced model. These tests assert that resolution serves the
+ * code catalog rather than a workspace body, so they follow the catalog
+ * instead of restating its pin.
+ */
+const MANAGED_BALANCED_MODEL = CODE_DEFAULT_PROFILE_ENTRIES.balanced
+  .model as string;
+
 function createProviderConnectionsDb(): DrizzleDb {
   const sqlite = new Database(":memory:");
   sqlite.exec("PRAGMA journal_mode=WAL");
@@ -669,7 +678,7 @@ describe("loadConfig startup behavior", () => {
     expect(raw.llm.profiles).toEqual({});
     // Default content resolves from the code catalog via the effective view.
     const effectiveBalanced = getEffectiveProfile(raw.llm.profiles, "balanced");
-    expect(effectiveBalanced?.model).toBe("gpt-5.6-luna");
+    expect(effectiveBalanced?.model).toBe(MANAGED_BALANCED_MODEL);
     expect(effectiveBalanced?.provider).toBe("vellum");
     expect(effectiveBalanced?.provider_connection).toBeUndefined();
   });
@@ -997,7 +1006,7 @@ describe("loadConfig startup behavior", () => {
     // Resolution ignores the drifted body: a managed-source entry contributes
     // only label/status/topP, everything else comes from the catalog.
     const effectiveBalanced = getEffectiveProfile(raw.llm.profiles, "balanced");
-    expect(effectiveBalanced?.model).toBe("gpt-5.6-luna");
+    expect(effectiveBalanced?.model).toBe(MANAGED_BALANCED_MODEL);
     expect(effectiveBalanced?.provider_connection).toBeUndefined();
   });
 
@@ -1077,7 +1086,7 @@ describe("loadConfig startup behavior", () => {
     expect(raw.llm.profiles.balanced).toEqual(drifted);
     expect(raw.llm.activeProfile).toBe("balanced");
     const effectiveBalanced = getEffectiveProfile(raw.llm.profiles, "balanced");
-    expect(effectiveBalanced?.model).toBe("gpt-5.6-luna");
+    expect(effectiveBalanced?.model).toBe(MANAGED_BALANCED_MODEL);
     expect(effectiveBalanced?.maxTokens).toBe(32000);
     expect(effectiveBalanced?.provider_connection).toBeUndefined();
     // The catalog body carries no topP and the entry has none, so the
@@ -1109,7 +1118,7 @@ describe("loadConfig startup behavior", () => {
     expect(raw.llm.profiles.balanced).toEqual(edited);
     const effectiveBalanced = getEffectiveProfile(raw.llm.profiles, "balanced");
     // Content is served from the catalog...
-    expect(effectiveBalanced?.model).toBe("gpt-5.6-luna");
+    expect(effectiveBalanced?.model).toBe(MANAGED_BALANCED_MODEL);
     // ...with the user's label and status overlaid.
     expect(effectiveBalanced?.label).toBe("My Default");
     expect(effectiveBalanced?.status).toBe("disabled");
@@ -1134,7 +1143,7 @@ describe("loadConfig startup behavior", () => {
     expect(raw.llm.profiles.balanced).toEqual(stub);
     const effectiveBalanced = getEffectiveProfile(raw.llm.profiles, "balanced");
     expect(effectiveBalanced?.label).toBe("My Default");
-    expect(effectiveBalanced?.model).toBe("gpt-5.6-luna");
+    expect(effectiveBalanced?.model).toBe(MANAGED_BALANCED_MODEL);
   });
 
   test("off-platform boot preserves user-toggled status on a managed stub", () => {
@@ -1156,7 +1165,7 @@ describe("loadConfig startup behavior", () => {
     expect(effectiveBalanced?.status).toBe("disabled");
     // Content still comes from the catalog — only label/status/topP are
     // workspace-owned.
-    expect(effectiveBalanced?.model).toBe("gpt-5.6-luna");
+    expect(effectiveBalanced?.model).toBe(MANAGED_BALANCED_MODEL);
   });
 
   test("boot preserves a user-edited topP override on a managed stub", () => {
@@ -1180,7 +1189,7 @@ describe("loadConfig startup behavior", () => {
     expect(effectiveBalanced?.topP).toBe(0.5);
     // Content still comes from the catalog — topP is workspace-owned, the
     // rest is code-owned.
-    expect(effectiveBalanced?.model).toBe("gpt-5.6-luna");
+    expect(effectiveBalanced?.model).toBe(MANAGED_BALANCED_MODEL);
   });
 
   test("effective balanced profile carries no topP override by default", () => {
@@ -1235,7 +1244,7 @@ describe("loadConfig startup behavior", () => {
     expect(raw.llm.profiles.balanced).toBeUndefined();
     const effectiveBalanced = getEffectiveProfile(raw.llm.profiles, "balanced");
     expect(effectiveBalanced?.label).toBe("Balanced");
-    expect(effectiveBalanced?.model).toBe("gpt-5.6-luna");
+    expect(effectiveBalanced?.model).toBe(MANAGED_BALANCED_MODEL);
     // Status is unset — the default resolves active.
     expect("status" in (effectiveBalanced ?? {})).toBe(false);
   });
@@ -1314,7 +1323,7 @@ describe("loadConfig startup behavior", () => {
     // overlay boot. The overlay-set label is what shows through the
     // effective view.
     expect(mainAgentConfig.provider).toBe("vellum");
-    expect(mainAgentConfig.model).toBe("gpt-5.6-luna");
+    expect(mainAgentConfig.model).toBe(MANAGED_BALANCED_MODEL);
 
     const raw = JSON.parse(readFileSync(CONFIG_PATH, "utf-8"));
     expect(raw.llm.profiles.balanced).toEqual({
@@ -1345,7 +1354,7 @@ describe("loadConfig startup behavior", () => {
     );
     expect(effectiveBalanced?.provider).toBe("vellum");
     expect(effectiveBalanced?.provider_connection).toBeUndefined();
-    expect(effectiveBalanced?.model).toBe("gpt-5.6-luna");
+    expect(effectiveBalanced?.model).toBe(MANAGED_BALANCED_MODEL);
     expect(effectiveBalanced?.maxTokens).toBe(32000);
     expect(effectiveBalanced?.thinking).toEqual({
       enabled: true,

package/src/__tests__/container-cpu-sampler.test.ts

@@ -0,0 +1,153 @@
+import { describe, expect, test } from "bun:test";
+
+import {
+  __resetContainerCpuSamplerForTests,
+  __runContainerCpuSamplerTickForTests,
+  computeCpuPercent,
+  computeDurationWeightedMeanPercent,
+  getAverageContainerCpuPercentOrNull,
+  getCachedContainerCpuPercent,
+  getCachedContainerCpuPercentOrNull,
+} from "../util/container-cpu-sampler.js";
+
+describe("computeCpuPercent", () => {
+  test("computes percent of the full allocation from a CPU-time delta", () => {
+    // 2.5s of CPU over a 5s window on 1 core is 50% of the allocation.
+    expect(computeCpuPercent(2_500_000, 5_000, 1)).toBe(50);
+    // The same delta on 2 cores is half the utilization.
+    expect(computeCpuPercent(2_500_000, 5_000, 2)).toBe(25);
+    // Fully saturating 4 cores for the whole window is 100%.
+    expect(computeCpuPercent(20_000_000, 5_000, 4)).toBe(100);
+  });
+
+  test("rounds to 2 decimal places", () => {
+    expect(computeCpuPercent(123_456, 5_000, 2)).toBe(1.23);
+    expect(computeCpuPercent(123_999, 5_000, 2)).toBe(1.24);
+    expect(computeCpuPercent(0, 5_000, 1)).toBe(0);
+  });
+
+  test("yields a non-finite result for zero cores, which callers must guard", () => {
+    expect(Number.isFinite(computeCpuPercent(1_000_000, 5_000, 0))).toBe(false);
+    expect(Number.isFinite(computeCpuPercent(0, 5_000, 0))).toBe(false);
+  });
+});
+
+describe("getCachedContainerCpuPercent", () => {
+  test("returns a finite number", () => {
+    expect(Number.isFinite(getCachedContainerCpuPercent())).toBe(true);
+  });
+});
+
+describe("getCachedContainerCpuPercentOrNull", () => {
+  test("returns null until the sampler computes its first delta", () => {
+    __resetContainerCpuSamplerForTests();
+
+    expect(getCachedContainerCpuPercentOrNull()).toBeNull();
+    // The plain accessor keeps its 0 placeholder for /v1/health.
+    expect(getCachedContainerCpuPercent()).toBe(0);
+
+    // Drive one sampler tick a full interval ahead of the reset baseline so
+    // it computes a real delta from process.cpuUsage().
+    __runContainerCpuSamplerTickForTests(Date.now() + 5_000);
+
+    const sampled = getCachedContainerCpuPercentOrNull();
+    expect(sampled).not.toBeNull();
+    expect(Number.isFinite(sampled!)).toBe(true);
+    expect(sampled).toBe(getCachedContainerCpuPercent());
+  });
+});
+
+describe("computeDurationWeightedMeanPercent", () => {
+  test("weights each percent by the wall time its delta spanned", () => {
+    // 25s at 80% then 5s at 100% is 83.33% of the half minute, not the 90%
+    // an equal-weight mean would report.
+    expect(
+      computeDurationWeightedMeanPercent(
+        [
+          { at: 25_000, percent: 80, elapsedMs: 25_000 },
+          { at: 30_000, percent: 100, elapsedMs: 5_000 },
+        ],
+        0,
+      ),
+    ).toBe(83.33);
+    // Equal durations degrade to the plain mean.
+    expect(
+      computeDurationWeightedMeanPercent(
+        [
+          { at: 5_000, percent: 40, elapsedMs: 5_000 },
+          { at: 10_000, percent: 60, elapsedMs: 5_000 },
+        ],
+        0,
+      ),
+    ).toBe(50);
+  });
+
+  test("clips a delayed tick's contribution to its overlap with the window", () => {
+    // A 25s CPU-bound stall at 100% ends 1s into the window; only that 1s
+    // may count. With 29s of idle at 10% after it, the window reads 13%,
+    // not the 52.8% an unclipped duration weighting would report.
+    expect(
+      computeDurationWeightedMeanPercent(
+        [
+          { at: 1_000, percent: 100, elapsedMs: 25_000 },
+          { at: 30_000, percent: 10, elapsedMs: 29_000 },
+        ],
+        0,
+      ),
+    ).toBe(13);
+    // A tick entirely before the window contributes nothing.
+    expect(
+      computeDurationWeightedMeanPercent(
+        [
+          { at: -1_000, percent: 100, elapsedMs: 5_000 },
+          { at: 10_000, percent: 20, elapsedMs: 10_000 },
+        ],
+        0,
+      ),
+    ).toBe(20);
+  });
+
+  test("returns null without any overlapping samples", () => {
+    expect(computeDurationWeightedMeanPercent([], 0)).toBeNull();
+    expect(
+      computeDurationWeightedMeanPercent(
+        [{ at: 5_000, percent: 50, elapsedMs: 0 }],
+        0,
+      ),
+    ).toBeNull();
+    expect(
+      computeDurationWeightedMeanPercent(
+        [{ at: -1_000, percent: 50, elapsedMs: 5_000 }],
+        0,
+      ),
+    ).toBeNull();
+  });
+});
+
+describe("getAverageContainerCpuPercentOrNull", () => {
+  test("returns null until a tick lands inside the window", () => {
+    __resetContainerCpuSamplerForTests();
+
+    expect(getAverageContainerCpuPercentOrNull(60_000)).toBeNull();
+  });
+
+  test("averages the ticks recorded within the trailing window", () => {
+    __resetContainerCpuSamplerForTests();
+
+    // A single recorded tick makes the average equal the last cached value.
+    __runContainerCpuSamplerTickForTests(Date.now() + 5_000);
+    const single = getAverageContainerCpuPercentOrNull(60_000);
+    expect(single).not.toBeNull();
+    expect(single).toBe(getCachedContainerCpuPercentOrNull());
+
+    // More ticks keep the average finite and within the recorded range; the
+    // exact value depends on real process CPU deltas, so only the invariant
+    // is asserted.
+    __runContainerCpuSamplerTickForTests(Date.now() + 10_000);
+    __runContainerCpuSamplerTickForTests(Date.now() + 15_000);
+    const averaged = getAverageContainerCpuPercentOrNull(60_000);
+    expect(averaged).not.toBeNull();
+    expect(Number.isFinite(averaged!)).toBe(true);
+    expect(averaged!).toBeGreaterThanOrEqual(0);
+  });
+});

package/src/__tests__/context-search-memory-v2-source.test.ts

@@ -71,7 +71,6 @@ mock.module("../plugins/defaults/memory/substrate/edge-index.js", () => ({
   getEdgeIndex: async (): Promise<EdgeIndex> => edgeIndex,
   invalidateEdgeIndex: () => {},
   getReachable: () => new Set<string>(),
-  validateEdgeTargets: () => ({ ok: true, missing: [] }),
   totalEdgeCount: () => 0,
 }));
 

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

@@ -15,7 +15,6 @@ mock.module("../permissions/checker.js", () => ({
   isDynamicSkillLoadInvocation: () => false,
   check: checkSpy,
   classifyRisk: () => Promise.resolve({ level: "low" }),
-  generateAllowlistOptions: () => Promise.resolve([]),
   generateScopeOptions: () => [],
 }));
 

package/src/__tests__/conversation-delete-watch-timeline.test.ts

@@ -0,0 +1,231 @@
+/**
+ * A watch session's timeline is the most sensitive thing a conversation owns:
+ * what the user narrated, and frames of their screen while they narrated it.
+ * Both live in the timeline row, so every path that removes a conversation has
+ * to take those rows with it.
+ *
+ * `clearAll` is the sharpest case. Its bulk deletes run in a sqlite3
+ * subprocess, so the daemon's event loop is free between them and an append
+ * can land mid-wipe. The timeline purge is the wipe's last statement, after
+ * `conversations` is emptied: an append that beat it is a row it deletes, and
+ * one that follows it has no conversation to key itself to.
+ */
+import { describe, expect, mock, test } from "bun:test";
+
+// Keep the rest of the module real; only the Qdrant collection drop is
+// replaced, so `clearAll` does not reach for a lexical index that is not
+// running here.
+const actualLexical =
+  await import("../persistence/job-handlers/message-lexical.js");
+mock.module("../persistence/job-handlers/message-lexical.js", () => ({
+  ...actualLexical,
+  clearMessagesLexicalIndex: async () => {},
+}));
+
+/**
+ * An append to run from inside the wipe, on the statement it is keyed to.
+ *
+ * Which interleaving a race test runs is otherwise up to whichever subprocess
+ * happens to be slow, and the interleaving that matters is a narrow one: the
+ * append has to write its row while `conversations` is still populated, so its
+ * own existence check has nothing to catch and only the wipe's ordering keeps
+ * the row from outliving the wipe.
+ */
+let appendDuringWipe: { onStatement: string; run: () => void } | null = null;
+
+// Every bulk delete in `clearAll` goes through `runAsyncSqlite`, which spawns
+// a sqlite3 subprocess and yields the event loop. The wrapper runs the real
+// statement and stands in for whatever else the daemon would have done while
+// it was in flight.
+const actualAsyncQuery = await import("../persistence/db-async-query.js");
+const realRunAsyncSqlite = actualAsyncQuery.runAsyncSqlite;
+mock.module("../persistence/db-async-query.js", () => ({
+  ...actualAsyncQuery,
+  runAsyncSqlite: async (
+    sql: string,
+    label: string,
+    options?: Parameters<typeof actualAsyncQuery.runAsyncSqlite>[2],
+  ) => {
+    const result = await realRunAsyncSqlite(sql, label, options);
+    if (appendDuringWipe && appendDuringWipe.onStatement === sql) {
+      const pending = appendDuringWipe;
+      appendDuringWipe = null;
+      pending.run();
+    }
+    return result;
+  },
+}));
+
+import {
+  clearAll,
+  createConversation,
+  deleteConversation,
+  deleteConversationGently,
+} from "../persistence/conversation-crud.js";
+import { getDb } from "../persistence/db-connection.js";
+import { initializeDb } from "../persistence/db-init.js";
+import { attachments } from "../persistence/schema/conversations.js";
+import type { WatchAppendResult } from "../watch/watch-timeline.js";
+import {
+  appendNarration,
+  appendObservation,
+  readWatchScreenshot,
+  renderWatchTimeline,
+} from "../watch/watch-timeline.js";
+
+await initializeDb();
+
+/** A 1x1 JPEG, the shape the host hands over on every observe. */
+const SCREENSHOT_BASE64 =
+  "/9j/4AAQSkZJRgABAQEAYABgAAD/2wBDAAgGBgcGBQgHBwcJCQgKDBQNDAsLDBkSEw8UHRofHh0aHBwgJC4nICIsIxwcKDcpLDAxNDQ0Hyc5PTgyPC4zNDL/2wBDAQkJCQwLDBgNDRgyIRwhMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjL/wAARCAABAAEDASIAAhEBAxEB/8QAHwAAAQUBAQEBAQEAAAAAAAAAAAECAwQFBgcICQoL/8QAtRAAAgEDAwIEAwUFBAQAAAF9AQIDAAQRBRIhMUEGE1FhByJxFDKBkaEII0KxwRVS0fAkM2JyggkKFhcYGRolJicoKSo0NTY3ODk6Q0RFRkdISUpTVFVWV1hZWmNkZWZnaGlqc3R1dnd4eXqDhIWGh4iJipKTlJWWl5iZmqKjpKWmp6ipqrKztLW2t7i5usLDxMXGx8jJytLT1NXW19jZ2uHi4+Tl5ufo6erx8vP09fb3+Pn6/8QAHwEAAwEBAQEBAQEBAQAAAAAAAAECAwQFBgcICQoL/8QAtREAAgECBAQDBAcFBAQAAQJ3AAECAxEEBSExBhJBUQdhcRMiMoEIFEKRobHBCSMzUvAVYnLRChYkNOEl8RcYGRomJygpKjU2Nzg5OkNERUZHSElKU1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6goOEhYaHiImKkpOUlZaXmJmaoqOkpaanqKmqsrO0tba3uLm6wsPExcbHyMnK0tPU1dbX2Nna4uPk5ebn6Onq8vP09fb3+Pn6/9oADAMBAAIRAxEAPwD3+iiigD//2Q==";
+
+interface WatchedConversation {
+  readonly conversationId: string;
+  readonly sessionId: string;
+  readonly entryId: string;
+}
+
+/** A conversation with one narration and one screenshot-carrying observation. */
+function seedWatchedConversation(title: string): WatchedConversation {
+  const conversation = createConversation(title);
+  const sessionId = `watch-${conversation.id}`;
+
+  appendObservation(sessionId, {
+    conversationId: conversation.id,
+    atMs: 1_000,
+    observation: { axTree: "window Mail", screenshot: SCREENSHOT_BASE64 },
+    attachScreenshot: true,
+  });
+  appendNarration(sessionId, {
+    conversationId: conversation.id,
+    atMs: 2_000,
+    text: "this is how I file it",
+  });
+
+  const rendered = renderWatchTimeline(sessionId);
+  expect(rendered.totalEntries).toBe(2);
+  const entryId = rendered.screenshotEntryIds[0];
+  expect(entryId).toBeDefined();
+  expect(readWatchScreenshot(entryId as string)).not.toBeNull();
+
+  return { conversationId: conversation.id, sessionId, entryId: entryId ?? "" };
+}
+
+function expectPurged(watched: WatchedConversation): void {
+  expect(renderWatchTimeline(watched.sessionId).totalEntries).toBe(0);
+  expect(readWatchScreenshot(watched.entryId)).toBeNull();
+}
+
+/** Every attachment row in the store. */
+function attachmentCount(): number {
+  return getDb().select({ id: attachments.id }).from(attachments).all().length;
+}
+
+describe("deleteConversation purges the watch timeline", () => {
+  test("takes the entries and the frames they carry", () => {
+    const watched = seedWatchedConversation("watched-sync");
+    const other = seedWatchedConversation("watched-sync-other");
+
+    // A timeline keeps its screenshots in its own rows, so watching a session
+    // stages nothing in the attachment store for a delete to chase.
+    expect(attachmentCount()).toBe(0);
+
+    deleteConversation(watched.conversationId);
+
+    expectPurged(watched);
+    // Scoped to the conversation being deleted, not the whole store.
+    expect(renderWatchTimeline(other.sessionId).totalEntries).toBe(2);
+    expect(readWatchScreenshot(other.entryId)).not.toBeNull();
+  });
+});
+
+describe("deleteConversationGently purges the watch timeline", () => {
+  test("the off-loop path clears the same state as the synchronous one", async () => {
+    const watched = seedWatchedConversation("watched-gentle");
+
+    await deleteConversationGently(watched.conversationId);
+
+    expectPurged(watched);
+  });
+});
+
+describe("an append that lands after the delete", () => {
+  test("is refused and leaves no row", () => {
+    const watched = seedWatchedConversation("watched-late-append");
+
+    deleteConversation(watched.conversationId);
+    const result = appendObservation(watched.sessionId, {
+      conversationId: watched.conversationId,
+      atMs: 3_000,
+      observation: { axTree: "window Mail", screenshot: SCREENSHOT_BASE64 },
+      attachScreenshot: true,
+    });
+
+    expect(result).toEqual({ ok: false, reason: "conversation_missing" });
+    expect(renderWatchTimeline(watched.sessionId).totalEntries).toBe(0);
+  });
+});
+
+describe("clearAll purges every watch timeline", () => {
+  test("wipes the entries and the frames they carry", async () => {
+    const first = seedWatchedConversation("watched-clear-all-a");
+    const second = seedWatchedConversation("watched-clear-all-b");
+
+    await clearAll();
+
+    expectPurged(first);
+    expectPurged(second);
+  });
+});
+
+describe("an append that lands inside a clear-all", () => {
+  test("does not outlive the wipe that overtook it", async () => {
+    const watched = seedWatchedConversation("watched-clear-all-race");
+
+    // The append runs where the wipe is most exposed: mid-sequence, with
+    // `conversations` still populated so its existence check has nothing to
+    // catch. Only the timeline purge coming after `conversations` keeps the
+    // row from surviving.
+    let landed: WatchAppendResult | null = null;
+    appendDuringWipe = {
+      onStatement: "DELETE FROM messages",
+      run: () => {
+        landed = appendObservation(watched.sessionId, {
+          conversationId: watched.conversationId,
+          atMs: 3_000,
+          observation: {
+            axTree: "window Mail",
+            screenshot: SCREENSHOT_BASE64,
+          },
+          attachScreenshot: true,
+        });
+      },
+    };
+
+    await clearAll();
+
+    // The row really did land, so the wipe had something to sweep.
+    const result = landed as WatchAppendResult | null;
+    expect(result?.ok).toBe(true);
+    expect(renderWatchTimeline(watched.sessionId).totalEntries).toBe(0);
+    expect(
+      readWatchScreenshot(result?.ok === true ? result.entryId : ""),
+    ).toBeNull();
+  });
+});
+
+describe("an append that arrives once the clear-all is done", () => {
+  test("is refused, because there is no conversation left to key it to", async () => {
+    const watched = seedWatchedConversation("watched-clear-all-after");
+
+    await clearAll();
+    const result = appendNarration(watched.sessionId, {
+      conversationId: watched.conversationId,
+      atMs: 3_000,
+      text: "too late",
+    });
+
+    expect(result).toEqual({ ok: false, reason: "conversation_missing" });
+    expect(renderWatchTimeline(watched.sessionId).totalEntries).toBe(0);
+  });
+});

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

@@ -521,6 +521,23 @@ describe("classifyConversationError", () => {
       expect(result.userMessage.toLowerCase()).toContain("image");
     });
 
+    it("classifies an OpenAI-compatible 400 for an unreadable image as image_unsupported_format (non-retryable)", () => {
+      // The rejection an OpenAI-compatible endpoint returns when any image in
+      // the request is not one of the formats it decodes (a HEIC photo renamed
+      // to .png, say). It names no index, so the whole turn dies unless it is
+      // classified for the image-recovery path with actionable copy.
+      const err = new ProviderError(
+        "The image data you provided does not represent a valid image. Please check your input and try again with one of the supported image formats: [image/jpeg, image/png, image/gif, image/webp]",
+        "openai",
+        400,
+      );
+      const result = classifyConversationError(err, baseCtx);
+      expect(result.code).toBe("IMAGE_TOO_LARGE");
+      expect(result.errorCategory).toBe("image_unsupported_format");
+      expect(result.retryable).toBe(false);
+      expect(result.userMessage.toLowerCase()).toContain("image");
+    });
+
     it("does not steal generic 400s that happen to mention 'image'", () => {
       const err = new ProviderError(
         "invalid request: image source is missing",

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

@@ -652,14 +652,12 @@ describe("loadFromDb metadata injection rehydration", () => {
     expect(messages[2].content).toEqual([{ type: "text", text: "Tail" }]);
   });
 
-  test("internal-channel trusted_contact view still rehydrates memoryV2StaticBlock", async () => {
-    // Rehydration keys on `sourceChannel`, not `trustClass`: injection uses
-    // `shouldExposePersonalMemory`, which exposes personal memory whenever
-    // `sourceChannel === "vellum"` regardless of actor trust class. So a
-    // trusted_contact view arriving over the internal `"vellum"` channel
-    // rehydrates `memoryV2StaticBlock`. The rehydrate gate must match
-    // injection so a daemon-restart reload of the same conversation produces
-    // an identical prefix.
+  test("internal-channel trusted_contact view does not rehydrate memoryV2StaticBlock", async () => {
+    // Rehydration keys on the actor, not the surface: a trusted_contact is
+    // denied personal memory on the internal `"vellum"` channel exactly as it
+    // is on a remote one. Injection and rehydration share
+    // `canSeePersonalMemory`, so a daemon-restart reload of the same
+    // conversation produces an identical prefix.
     mockConversation = defaultConv();
     mockDbMessages = [
       {
@@ -697,13 +695,8 @@ describe("loadFromDb metadata injection rehydration", () => {
     const messages = conversation.getMessages();
 
     expect(messages).toHaveLength(3);
-    expect(messages[0].content).toEqual([
-      {
-        type: "text",
-        text: "<info>\n## Essentials\n\nAlice prefers VS Code.\n</info>",
-      },
-      { type: "text", text: "First" },
-    ]);
+    // The persisted block stays out: the console is a surface, not an actor.
+    expect(messages[0].content).toEqual([{ type: "text", text: "First" }]);
   });
 
   test("rehydration order matches injection-time order for the full personal-memory set", async () => {
@@ -1047,12 +1040,14 @@ describe("loadFromDb metadata injection rehydration", () => {
     expect(messages[2].content).toEqual([{ type: "text", text: "Tail" }]);
   });
 
-  test("ensureActorScopedHistory reloads when sourceChannel changes within the same trust class", async () => {
-    // Regression: cache invalidation previously keyed only on trust class.
-    // `loadFromDb` gates `memoryV2StaticBlock` rehydration on `sourceChannel`
-    // via `shouldExposePersonalMemory`, so a same-trust-class reuse from a
-    // different channel (e.g. internal `vellum` → remote channel) must
-    // re-run `loadFromDb` or stale personal-memory exposure persists.
+  test("ensureActorScopedHistory reloads when the actor's memory visibility changes", async () => {
+    // Reuse of a resident conversation by a different actor must re-run
+    // `loadFromDb`, or the incoming actor inherits the previous actor's
+    // transcript with its personal-memory blocks still spliced in.
+    //
+    // Driven by a trust-class change rather than a channel change: personal
+    // memory is keyed on the actor, so two channels at the same class are the
+    // same view and reloading between them would prove nothing.
     mockConversation = defaultConv();
     mockDbMessages = [
       {
@@ -1080,10 +1075,9 @@ describe("loadFromDb metadata injection rehydration", () => {
     ];
 
     const conversation = makeConversation();
-    // First load: internal channel, trusted_contact actor → personal memory
-    // exposed via `shouldExposePersonalMemory({sourceChannel: "vellum", ...})`.
+    // First load: guardian actor → personal memory exposed.
     conversation.setTrustContext({
-      trustClass: "trusted_contact",
+      trustClass: "guardian",
       sourceChannel: "vellum",
     });
     await conversation.ensureActorScopedHistory();
@@ -1095,8 +1089,8 @@ describe("loadFromDb metadata injection rehydration", () => {
       { type: "text", text: "First" },
     ]);
 
-    // Reuse with the same trust class but a remote channel. The cache must
-    // invalidate and trigger a reload that strips the personal-memory block.
+    // Reuse by a contact. The cache must invalidate and trigger a reload that
+    // strips the personal-memory block.
     conversation.setTrustContext({
       trustClass: "trusted_contact",
       sourceChannel: "telegram",