@vellumai/assistant 0.8.9-staging.2 → 0.8.9-staging.4

package/src/__tests__/agent-loop-output-hooks.test.ts

@@ -1,5 +1,5 @@
 /**
- * Tests for the `pre-model-call` and `assistant-message` plugin hooks: a plugin
+ * Tests for the `pre-model-call` and `post-model-call` plugin hooks: a plugin
  * can edit the outbound request, transform the finalized assistant message
  * (persisted + streamed), and defer the live stream so the transformed text is
  * emitted once. All hooks here use neutral transforms (redaction / uppercasing).
@@ -9,7 +9,7 @@ import { beforeEach, describe, expect, test } from "bun:test";
 import type { AgentEvent } from "../agent/loop.js";
 import { AgentLoop } from "../agent/loop.js";
 import type {
-  AssistantMessageContext,
+  PostModelCallContext,
   PreModelCallContext,
 } from "../plugin-api/types.js";
 import { resetPluginRegistryAndRegisterDefaults } from "../plugins/defaults/index.js";
@@ -55,7 +55,7 @@ function lastAssistant(history: Message[]): Message {
 
 function registerOutputHookPlugin(hooks: {
   preModelCall?: (ctx: PreModelCallContext) => void;
-  assistantMessage?: (ctx: AssistantMessageContext) => void;
+  postModelCall?: (ctx: PostModelCallContext) => void;
 }): void {
   registerPlugin({
     manifest: { name: "test-output-hooks", version: "0.0.0" },
@@ -67,10 +67,10 @@ function registerOutputHookPlugin(hooks: {
             },
           }
         : {}),
-      ...(hooks.assistantMessage
+      ...(hooks.postModelCall
         ? {
-            "assistant-message": async (ctx: AssistantMessageContext) => {
-              hooks.assistantMessage!(ctx);
+            "post-model-call": async (ctx: PostModelCallContext) => {
+              hooks.postModelCall!(ctx);
             },
           }
         : {}),
@@ -83,9 +83,9 @@ describe("agent loop output hooks", () => {
     resetPluginRegistryAndRegisterDefaults();
   });
 
-  test("assistant-message transforms the persisted message content", async () => {
+  test("post-model-call transforms the persisted message content", async () => {
     registerOutputHookPlugin({
-      assistantMessage: (ctx) => {
+      postModelCall: (ctx) => {
         ctx.content = ctx.content.map((b) =>
           b.type === "text"
             ? { type: "text", text: b.text.replace("secret", "[redacted]") }
@@ -113,7 +113,7 @@ describe("agent loop output hooks", () => {
       preModelCall: (ctx) => {
         ctx.deferAssistantOutput = true;
       },
-      assistantMessage: (ctx) => {
+      postModelCall: (ctx) => {
         ctx.content = [{ type: "text", text: "[filtered]" }];
       },
     });
@@ -137,7 +137,7 @@ describe("agent loop output hooks", () => {
 
   test("without defer, the real text still streams while storage is transformed", async () => {
     registerOutputHookPlugin({
-      assistantMessage: (ctx) => {
+      postModelCall: (ctx) => {
         ctx.content = [{ type: "text", text: "[stored]" }];
       },
     });
@@ -168,7 +168,7 @@ describe("agent loop output hooks", () => {
       stopReason: "tool_use",
     };
     registerOutputHookPlugin({
-      assistantMessage: (ctx) => {
+      postModelCall: (ctx) => {
         ctx.content = ctx.content.map((b) =>
           b.type === "text" ? { type: "text", text: b.text.toUpperCase() } : b,
         );
@@ -237,7 +237,7 @@ describe("agent loop output hooks", () => {
     // mid-mutation would survive into history. The loop must clone the
     // content before invoking the hook.
     registerOutputHookPlugin({
-      assistantMessage: (ctx) => {
+      postModelCall: (ctx) => {
         ctx.content.push({ type: "text", text: "[INJECTED]" });
         throw new Error("boom");
       },
@@ -269,7 +269,7 @@ describe("agent loop output hooks", () => {
       preModelCall: (ctx) => {
         ctx.deferAssistantOutput = true;
       },
-      assistantMessage: (ctx) => {
+      postModelCall: (ctx) => {
         seen.calls += 1;
         ctx.content = ctx.content.map((b) =>
           b.type === "text" ? { type: "text", text: b.text.toUpperCase() } : b,

package/src/__tests__/anthropic-provider.test.ts

@@ -2,7 +2,11 @@ import { beforeEach, describe, expect, mock, test } from "bun:test";
 
 import type { Anthropic } from "@anthropic-ai/sdk";
 
-import type { Message, ToolDefinition } from "../providers/types.js";
+import type {
+  ContentBlock,
+  Message,
+  ToolDefinition,
+} from "../providers/types.js";
 
 // ---------------------------------------------------------------------------
 // Mock Anthropic SDK — must be before importing the provider
@@ -102,7 +106,6 @@ mock.module("@anthropic-ai/sdk", () => ({
 }));
 
 // Import after mocking
-import { cachedTextBlock } from "../plugins/defaults/memory-v3-shadow/provider-blocks.js";
 import { AnthropicProvider } from "../providers/anthropic/client.js";
 import {
   isPlaceholderSentinelText,
@@ -138,6 +141,18 @@ function toolResultMsg(toolUseId: string, content: string): Message {
   };
 }
 
+// A stable prefix text block carrying a 1h-TTL cache_control breakpoint, as a
+// caller may stamp before the provider sees it. The internal ContentBlock type
+// omits cache_control (only the provider transforms it onto the wire), so reach
+// it via a cast.
+function cachedPrefixBlock(text: string): ContentBlock {
+  return {
+    type: "text",
+    text,
+    cache_control: { type: "ephemeral", ttl: "1h" },
+  } as unknown as ContentBlock;
+}
+
 const sampleTools: ToolDefinition[] = [
   {
     name: "file_read",
@@ -325,13 +340,13 @@ describe("AnthropicProvider — Cache-Control Characterization", () => {
   });
 
   test("preserves a caller's 1h block cache_control and sends the extended-cache beta (non-Haiku)", async () => {
-    // v3's `cachedTextBlock` stamps a stable prefix block with a 1h TTL; the
-    // non-Haiku path must forward it unchanged and send the beta header.
+    // A caller that stamps a stable prefix block with a 1h TTL: the non-Haiku
+    // path must forward it unchanged and send the beta header.
     await provider.sendMessage([
       {
         role: "user",
         content: [
-          cachedTextBlock("stable pages block"),
+          cachedPrefixBlock("stable pages block"),
           { type: "text", text: "volatile current message" },
         ],
       },
@@ -349,7 +364,7 @@ describe("AnthropicProvider — Cache-Control Characterization", () => {
 
   test("strips ttl from a caller's block cache_control and omits the beta for Haiku", async () => {
     // Haiku doesn't support the extended-cache-ttl beta, so a caller-stamped
-    // 1h ttl (e.g. from `cachedTextBlock`) must be stripped before sending.
+    // 1h ttl on a message block must be stripped before sending.
     const haiku = new AnthropicProvider(
       "sk-ant-test",
       "claude-haiku-4-5-20251001",
@@ -358,7 +373,7 @@ describe("AnthropicProvider — Cache-Control Characterization", () => {
       {
         role: "user",
         content: [
-          cachedTextBlock("stable pages block"),
+          cachedPrefixBlock("stable pages block"),
           { type: "text", text: "volatile current message" },
         ],
       },
@@ -385,7 +400,7 @@ describe("AnthropicProvider — Cache-Control Characterization", () => {
         {
           role: "user",
           content: [
-            cachedTextBlock("stable pages block"),
+            cachedPrefixBlock("stable pages block"),
             { type: "text", text: "volatile current message" },
           ],
         },

package/src/__tests__/approval-cascade.test.ts

@@ -173,7 +173,7 @@ mock.module("../memory/retriever.js", () => ({
   injectMemoryRecallAsUserBlock: (msgs: Message[]) => msgs,
 }));
 
-mock.module("../context/window-manager.js", () => ({
+mock.module("../plugins/defaults/compaction/window-manager.js", () => ({
   ContextWindowManager: class {
     constructor() {}
     updateConfig() {}

package/src/__tests__/compaction-direct.test.ts

@@ -3,19 +3,29 @@
  *
  * The agent loop calls {@link defaultCompact} directly with a
  * {@link CompactionContext} rather than routing through a middleware pipeline.
- * These tests assert that the default implementation delegates to the
- * supplied {@link ContextWindowManager} and forwards the request's
- * conversational options verbatim. The orchestrator integration path
- * (conversation-agent-loop) is exercised by
+ * These tests assert that the default implementation resolves the
+ * conversation's {@link ContextWindowManager} from the compaction store and
+ * forwards the request's conversational options verbatim. The orchestrator
+ * integration path (conversation-agent-loop) is exercised by
  * `conversation-agent-loop-overflow.test.ts`.
  */
 
-import { describe, expect, test } from "bun:test";
+import { describe, expect, mock, test } from "bun:test";
 
-import {
-  type CompactionContext,
-  defaultCompact,
-} from "../plugins/defaults/compaction/compact.js";
+// `defaultCompact` resolves the manager from the per-conversation compaction
+// store. Register each test's canned stub in a map the mocked store reads from.
+const fakeContextWindowManagers = new Map<string, unknown>();
+mock.module("../plugins/defaults/compaction/manager-store.js", () => ({
+  createContextWindowManager: () => undefined,
+  getContextWindowManager: (conversationId: string) =>
+    fakeContextWindowManagers.get(conversationId),
+  disposeContextWindowManager: (conversationId: string) => {
+    fakeContextWindowManagers.delete(conversationId);
+  },
+}));
+
+const { defaultCompact } =
+  await import("../plugins/defaults/compaction/compact.js");
 
 type ContextWindowResultShape = {
   compacted: boolean;
@@ -55,13 +65,17 @@ function makeResult(
   };
 }
 
-function makeManager(result: ContextWindowResultShape) {
+/** Register a stub manager under a conversation id and return its recorder. */
+function registerManager(
+  conversationId: string,
+  result: ContextWindowResultShape,
+) {
   const observed: {
     messages: unknown;
     signal: unknown;
     options: unknown;
   }[] = [];
-  const manager = {
+  fakeContextWindowManagers.set(conversationId, {
     maybeCompact: async (
       messages: unknown,
       signal: unknown,
@@ -70,8 +84,8 @@ function makeManager(result: ContextWindowResultShape) {
       observed.push({ messages, signal, options });
       return result;
     },
-  } as unknown as CompactionContext["manager"];
-  return { manager, observed };
+  });
+  return observed;
 }
 
 describe("defaultCompact", () => {
@@ -81,13 +95,13 @@ describe("defaultCompact", () => {
       summaryText: "manager-summary",
       compactedMessages: 7,
     });
-    const { manager, observed } = makeManager(expected);
+    const observed = registerManager("conv-delegates", expected);
     const messages = [{ role: "user", content: "hi" }] as never;
     const signal = new AbortController().signal;
 
     // WHEN defaultCompact runs with those messages and a signal
     const result = (await defaultCompact({
-      manager,
+      conversationId: "conv-delegates",
       messages,
       signal,
     })) as unknown as ContextWindowResultShape;
@@ -105,11 +119,11 @@ describe("defaultCompact", () => {
 
   test("forwards the request's compaction options to the manager", async () => {
     // GIVEN a manager and a fully-populated compaction context
-    const { manager, observed } = makeManager(makeResult());
+    const observed = registerManager("conv-options", makeResult());
 
     // WHEN defaultCompact runs with force/profile/trust options
     await defaultCompact({
-      manager,
+      conversationId: "conv-options",
       messages: [] as never,
       force: true,
       overrideProfile: "fast-profile",
@@ -118,7 +132,7 @@ describe("defaultCompact", () => {
       actorTrustClass: "guardian",
     });
 
-    // THEN the manager received exactly those options, and the manager,
+    // THEN the manager received exactly those options, and the conversation id,
     // messages, and signal are not leaked into the options bag
     expect(observed).toHaveLength(1);
     expect(observed[0]!.options).toEqual({

package/src/__tests__/compaction-events.test.ts

@@ -12,8 +12,8 @@ import { describe, expect, mock, test } from "bun:test";
 
 import { CompactionCircuit } from "../agent/compaction-circuit.js";
 import type { AgentEvent } from "../agent/loop.js";
-import type { ContextWindowResult } from "../context/window-manager.js";
 import type { ServerMessage } from "../daemon/message-protocol.js";
+import type { ContextWindowResult } from "../plugins/defaults/compaction/window-manager.js";
 import type { Message, ProviderResponse } from "../providers/types.js";
 
 // ---------------------------------------------------------------------------
@@ -187,7 +187,7 @@ let mockCompactResult: ContextWindowResult = {
   summaryText: "",
 };
 
-mock.module("../context/window-manager.js", () => ({
+mock.module("../plugins/defaults/compaction/window-manager.js", () => ({
   ContextWindowManager: class {
     nonPersistedPrefixCount = 0;
     constructor() {}

package/src/__tests__/compaction.benchmark.test.ts

@@ -12,7 +12,7 @@ import { describe, expect, mock, test } from "bun:test";
 
 import { DEFAULT_CONFIG } from "../config/defaults.js";
 import { estimatePromptTokens } from "../context/token-estimator.js";
-import { ContextWindowManager } from "../context/window-manager.js";
+import { ContextWindowManager } from "../plugins/defaults/compaction/window-manager.js";
 import type { Message, Provider } from "../providers/types.js";
 
 mock.module("../util/logger.js", () => ({

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

@@ -1,17 +1,17 @@
 import { describe, expect, test } from "bun:test";
 
 import { estimatePromptTokens } from "../context/token-estimator.js";
-import type {
-  ContextWindowCompactOptions,
-  ContextWindowResult,
-} from "../context/window-manager.js";
-import { createContextSummaryMessage } from "../context/window-manager.js";
 import {
   createInitialReducerState,
   reduceContextOverflow,
   type ReducerConfig,
   type ReducerState,
 } from "../plugins/defaults/compaction/context-overflow-reducer.js";
+import type {
+  ContextWindowCompactOptions,
+  ContextWindowResult,
+} from "../plugins/defaults/compaction/window-manager.js";
+import { createContextSummaryMessage } from "../plugins/defaults/compaction/window-manager.js";
 import type { Message } from "../providers/types.js";
 
 function msg(role: "user" | "assistant", text: string): Message {

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

@@ -56,6 +56,11 @@ let runCalls: Array<{
 let runResults: CompactionRunResult[] = [];
 const estimateReturns: number[] = [];
 
+// Captured arguments from each runEmergencyCompaction invocation, so the
+// emergencyCompact tests can assert the manager fills in the fields it owns.
+let emergencyCalls: Record<string, unknown>[] = [];
+let emergencyResult: CompactionRunResult | undefined;
+
 mock.module("../context/token-estimator.js", () => ({
   estimatePromptTokens: (): number => {
     const next = estimateReturns.shift();
@@ -92,9 +97,18 @@ mock.module("../context/compactor.js", () => ({
     }
     return result;
   },
+  runEmergencyCompaction: async (
+    args: Record<string, unknown>,
+  ): Promise<CompactionRunResult> => {
+    emergencyCalls.push(args);
+    if (!emergencyResult) {
+      throw new Error("emergencyResult not seeded");
+    }
+    return emergencyResult;
+  },
 }));
 
-import { ContextWindowManager } from "../context/window-manager.js";
+import { ContextWindowManager } from "../plugins/defaults/compaction/window-manager.js";
 import type { Message, Provider } from "../providers/types.js";
 
 function makeProvider(): Provider {
@@ -142,24 +156,28 @@ function compactResult(
   };
 }
 
+function makeConfig(maxAttempts: number = 3) {
+  return {
+    enabled: true,
+    maxInputTokens: 200_000,
+    targetBudgetRatio: 0.3,
+    compactThreshold: 0.8,
+    summaryBudgetRatio: 0.05,
+    overflowRecovery: {
+      enabled: true,
+      safetyMarginRatio: 0.05,
+      maxAttempts,
+      interactiveLatestTurnCompression: "summarize" as const,
+      nonInteractiveLatestTurnCompression: "summarize" as const,
+    },
+  };
+}
+
 function buildManager(maxAttempts: number = 3): ContextWindowManager {
   return new ContextWindowManager({
     provider: makeProvider(),
     systemPrompt: "you are a test assistant",
-    config: {
-      enabled: true,
-      maxInputTokens: 200_000,
-      targetBudgetRatio: 0.3,
-      compactThreshold: 0.8,
-      summaryBudgetRatio: 0.05,
-      overflowRecovery: {
-        enabled: true,
-        safetyMarginRatio: 0.05,
-        maxAttempts,
-        interactiveLatestTurnCompression: "summarize",
-        nonInteractiveLatestTurnCompression: "summarize",
-      },
-    },
+    config: makeConfig(maxAttempts),
     conversationId: "conv-test",
   });
 }
@@ -289,3 +307,91 @@ describe("ContextWindowManager.maybeCompact retry budget", () => {
     expect(result.estimatedInputTokens).toBe(165_000);
   });
 });
+
+describe("ContextWindowManager.emergencyCompact", () => {
+  beforeEach(() => {
+    emergencyCalls = [];
+    emergencyResult = undefined;
+    estimateReturns.length = 0;
+  });
+
+  test("supplies manager-owned fields and forwards only overflow inputs", async () => {
+    /**
+     * The manager owns provider, system prompt, token budget, conversation
+     * id, compaction config, and non-persisted prefix count; the caller
+     * provides only the overflow-specific inputs.
+     */
+    // GIVEN a manager seeded with a non-persisted prefix and a canned result
+    emergencyResult = compactResult({
+      compacted: true,
+      compactedMessages: 40,
+      summaryText: "emergency summary",
+    });
+    const manager = buildManager();
+    manager.seedNonPersistedPrefix(3);
+    const messages = makeMessages(8);
+    const signal = new AbortController().signal;
+
+    // WHEN emergency compaction runs
+    const result = await manager.emergencyCompact(
+      messages,
+      { previousEstimatedInputTokens: 242_201, overrideProfile: "fast" },
+      signal,
+    );
+
+    // THEN the manager fills its owned fields and forwards the caller inputs
+    expect(emergencyCalls.length).toBe(1);
+    const args = emergencyCalls[0]!;
+    expect(args.conversationId).toBe("conv-test");
+    expect(args.systemPrompt).toBe("you are a test assistant");
+    expect(args.maxInputTokens).toBe(200_000);
+    expect(args.nonPersistedPrefixCount).toBe(3);
+    expect(args.tools).toBeUndefined();
+    expect(args.force).toBe(true);
+    expect(args.signal).toBe(signal);
+    expect(args.messages).toBe(messages);
+    expect(args.previousEstimatedInputTokens).toBe(242_201);
+    expect(args.overrideProfile).toBe("fast");
+    expect((args.provider as { name: string }).name).toBe("mock-provider");
+    expect(result.summaryText).toBe("emergency summary");
+  });
+
+  test("defaults overrideProfile to null when omitted", async () => {
+    /**
+     * Callers that don't resolve a per-conversation profile get an explicit
+     * null forwarded to the summary call.
+     */
+    // GIVEN a manager and a canned result
+    emergencyResult = compactResult({ compacted: true });
+    const manager = buildManager();
+
+    // WHEN emergency compaction runs without an override profile
+    await manager.emergencyCompact(makeMessages(6), {
+      previousEstimatedInputTokens: 210_000,
+    });
+
+    // THEN overrideProfile is forwarded as null
+    expect(emergencyCalls[0]!.overrideProfile).toBeNull();
+  });
+
+  test("throws when the manager has no conversation id", async () => {
+    /**
+     * Emergency compaction needs a conversation id for attachment and
+     * timestamp lookups; a manager without one cannot run it.
+     */
+    // GIVEN a manager constructed without a conversation id
+    const manager = new ContextWindowManager({
+      provider: makeProvider(),
+      systemPrompt: "you are a test assistant",
+      config: makeConfig(),
+    });
+
+    // WHEN/THEN emergency compaction rejects without invoking the compactor
+    await expect(
+      manager.emergencyCompact(makeMessages(4), {
+        previousEstimatedInputTokens: 210_000,
+      }),
+    ).rejects.toThrow(/conversationId/);
+    expect(emergencyCalls.length).toBe(0);
+  });
+});

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

@@ -167,7 +167,7 @@ mock.module("../memory/retriever.js", () => ({
   injectMemoryRecallAsUserBlock: (msgs: Message[]) => msgs,
 }));
 
-mock.module("../context/window-manager.js", () => ({
+mock.module("../plugins/defaults/compaction/window-manager.js", () => ({
   ContextWindowManager: class {
     constructor() {}
     updateConfig() {}

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

@@ -164,7 +164,7 @@ mock.module("../memory/retriever.js", () => ({
   injectMemoryRecallAsUserBlock: (msgs: Message[]) => msgs,
 }));
 
-mock.module("../context/window-manager.js", () => ({
+mock.module("../plugins/defaults/compaction/window-manager.js", () => ({
   ContextWindowManager: class {
     constructor() {}
     updateConfig() {}

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

@@ -319,7 +319,6 @@ describe("classifyConversationError", () => {
       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", () => {
@@ -333,6 +332,21 @@ describe("classifyConversationError", () => {
       expect(result.retryable).toBe(false);
     });
 
+    it("classifies the base64 payload 'exceeds 5 MB maximum' variant as IMAGE_TOO_LARGE (JARVIS-1041)", () => {
+      // This is the exact shape that wedged the reporting user: an oversized
+      // image nested in a tool_result. It must route to IMAGE_TOO_LARGE so the
+      // recovery path fires, not to a retryable PROVIDER_API loop.
+      const err = new ProviderError(
+        'Anthropic API error (400): 400 {"type":"error","error":{"type":"invalid_request_error","message":"messages.28.content.1.tool_result.content.1.image.source.base64: image exceeds 5 MB maximum: 7465044 bytes > 5242880 bytes"},"request_id":"req_011CbbFqvxBmDQdhVlqxtAfW"}',
+        "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);
+    });
+
     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-history-web-search.test.ts

@@ -809,6 +809,11 @@ describe("web_search_tool_result structural guard", () => {
     // contentBlocks property, so it cannot contain nested media.
     "plugins/defaults/compaction/context-overflow-reducer.ts",
 
+    // Downgrades permanently-unsendable images nested in tool_result.contentBlocks
+    // (e.g. an oversized browser screenshot). web_search_tool_result has opaque
+    // content with no contentBlocks property, so it cannot hold such an image.
+    "daemon/persist-unsendable-image.ts",
+
     // Final orphan-pair safety pass in the Slack transcript renderer.
     // Server-side block types (`server_tool_use`, `web_search_tool_result`)
     // are stripped earlier by `buildMessageContentBlocks` and cannot reach

package/src/__tests__/conversation-media-retry.test.ts

@@ -1,7 +1,7 @@
 import { describe, expect, test } from "bun:test";
 
-import { createContextSummaryMessage } from "../context/window-manager.js";
 import { stripMediaPayloadsForRetry } from "../daemon/conversation-media-retry.js";
+import { createContextSummaryMessage } from "../plugins/defaults/compaction/window-manager.js";
 import type { ContentBlock, Message } from "../providers/types.js";
 
 // ---------------------------------------------------------------------------

package/src/__tests__/conversation-process-app-control-preactivation.test.ts

@@ -185,6 +185,7 @@ function makeQueuedMessage(opts: {
   requestId: string;
   content?: string;
   turnInterfaceContext?: TurnInterfaceContext;
+  sourceActorPrincipalId?: string;
 }): QueuedMessage {
   return {
     content: opts.content ?? "follow up",
@@ -194,6 +195,10 @@ function makeQueuedMessage(opts: {
     metadata: {},
     sentAt: Date.now(),
     turnInterfaceContext: opts.turnInterfaceContext,
+    sourceActorPrincipalId: opts.sourceActorPrincipalId,
+    authContext: opts.sourceActorPrincipalId
+      ? ({ actorPrincipalId: opts.sourceActorPrincipalId } as never)
+      : undefined,
   };
 }
 
@@ -332,6 +337,7 @@ describe("drainQueue preactivation re-add for host-proxy interfaces", () => {
       makeQueuedMessage({
         requestId: "req-web-1",
         turnInterfaceContext: ifCtx,
+        sourceActorPrincipalId: "user-1",
       }),
     );
     const ctx = makeFakeContext({ queue, turnInterfaceContext: ifCtx });
@@ -346,6 +352,39 @@ describe("drainQueue preactivation re-add for host-proxy interfaces", () => {
     expect(ctx.preactivatedSkillIdCalls).toContain("computer-use");
   });
 
+  test("drainSingleMessage filters cross-client preactivation by the queued requester, not guardian owner", async () => {
+    mockCapabilityClients = [
+      { clientId: "owner-macos-client", actorPrincipalId: "owner-user" },
+    ];
+    const queue = new MessageQueue();
+    const ifCtx: TurnInterfaceContext = {
+      userMessageInterface: "web",
+      assistantMessageInterface: "web",
+    };
+    queue.push(
+      makeQueuedMessage({
+        requestId: "req-web-attacker",
+        turnInterfaceContext: ifCtx,
+        sourceActorPrincipalId: "trusted-contact-user",
+      }),
+    );
+    const ctx = makeFakeContext({ queue, turnInterfaceContext: ifCtx });
+    ctx.trustContext = {
+      trustClass: "trusted_contact",
+      guardianPrincipalId: "owner-user",
+      sourceChannel: "vellum",
+    };
+
+    await drainQueue(ctx);
+
+    expect(ctx.preactivatedSkillIdCalls).not.toContain("computer-use");
+    expect(ctx.preactivatedSkillIdCalls).not.toContain("app-control");
+    expect(ctx.currentTurnAuthContext?.actorPrincipalId).toBe(
+      "trusted-contact-user",
+    );
+    expect(ctx.currentTurnSourceActorPrincipalId).toBe("trusted-contact-user");
+  });
+
   test("drainSingleMessage does NOT re-add 'app-control' for web-sourced message when no capable client is connected", async () => {
     // mockCapabilityClients remains [] (reset by afterEach from prior test)
     const queue = new MessageQueue();
@@ -380,6 +419,7 @@ describe("drainQueue preactivation re-add for host-proxy interfaces", () => {
       makeQueuedMessage({
         requestId: "req-web-3",
         turnInterfaceContext: ifCtx,
+        sourceActorPrincipalId: "user-1",
       }),
     );
     const ctx = makeFakeContext({ queue, turnInterfaceContext: ifCtx });

package/src/__tests__/conversation-process-callsite.test.ts

@@ -249,7 +249,7 @@ mock.module("../agent/loop.js", () => ({
   },
 }));
 
-mock.module("../context/window-manager.js", () => ({
+mock.module("../plugins/defaults/compaction/window-manager.js", () => ({
   ContextWindowManager: class {
     constructor() {}
     updateConfig() {}