@vellumai/assistant 0.8.8 → 0.8.9-dev.202606091926.ebb2d62

package/src/__tests__/conversation-workspace-cache-state.test.ts

@@ -137,9 +137,10 @@ mock.module("../memory/retrieval-budget.js", () => ({
   computeRecallBudget: () => 0,
 }));
 
-mock.module("../context/window-manager.js", () => ({
+mock.module("../plugins/defaults/compaction/window-manager.js", () => ({
   ContextWindowManager: class {
     constructor() {}
+    updateConfig() {}
     shouldCompact() {
       return { needed: false, estimatedTokens: 0 };
     }
@@ -176,10 +177,11 @@ mock.module("../agent/loop.js", () => ({
     getActiveModel() {
       return undefined;
     }
-    async run(
-      messages: Message[],
-      onEvent: (event: AgentEvent) => void,
-    ): Promise<Message[]> {
+    async run(options: {
+      messages: Message[];
+      onEvent: (event: AgentEvent) => void;
+    }): Promise<Message[]> {
+      const { messages, onEvent } = options;
       const assistantMessage: Message = {
         role: "assistant",
         content: [{ type: "text", text: "ok" }],
@@ -198,6 +200,7 @@ mock.module("../agent/loop.js", () => ({
 }));
 
 import { Conversation } from "../daemon/conversation.js";
+import { refreshWorkspaceTopLevelContextIfNeeded } from "../daemon/conversation-workspace.js";
 
 // ---------------------------------------------------------------------------
 // Helpers
@@ -249,7 +252,7 @@ describe("Conversation workspace cache state", () => {
   });
 
   test("refreshWorkspaceTopLevelContextIfNeeded populates context and clears dirty", () => {
-    conversation.refreshWorkspaceTopLevelContextIfNeeded();
+    refreshWorkspaceTopLevelContextIfNeeded(conversation);
 
     expect(conversation.isWorkspaceTopLevelDirty()).toBe(false);
     expect(conversation.getWorkspaceTopLevelContext()).not.toBeNull();
@@ -265,10 +268,10 @@ describe("Conversation workspace cache state", () => {
   });
 
   test("refreshWorkspaceTopLevelContextIfNeeded no-ops when not dirty and cache exists", () => {
-    conversation.refreshWorkspaceTopLevelContextIfNeeded();
+    refreshWorkspaceTopLevelContextIfNeeded(conversation);
     const first = conversation.getWorkspaceTopLevelContext();
 
-    conversation.refreshWorkspaceTopLevelContextIfNeeded();
+    refreshWorkspaceTopLevelContextIfNeeded(conversation);
     const second = conversation.getWorkspaceTopLevelContext();
 
     // Same reference — no recomputation
@@ -276,7 +279,7 @@ describe("Conversation workspace cache state", () => {
   });
 
   test("markWorkspaceTopLevelDirty sets dirty flag", () => {
-    conversation.refreshWorkspaceTopLevelContextIfNeeded();
+    refreshWorkspaceTopLevelContextIfNeeded(conversation);
     expect(conversation.isWorkspaceTopLevelDirty()).toBe(false);
 
     conversation.markWorkspaceTopLevelDirty();
@@ -284,10 +287,10 @@ describe("Conversation workspace cache state", () => {
   });
 
   test("refresh after marking dirty produces fresh context", () => {
-    conversation.refreshWorkspaceTopLevelContextIfNeeded();
+    refreshWorkspaceTopLevelContextIfNeeded(conversation);
 
     conversation.markWorkspaceTopLevelDirty();
-    conversation.refreshWorkspaceTopLevelContextIfNeeded();
+    refreshWorkspaceTopLevelContextIfNeeded(conversation);
 
     expect(conversation.getWorkspaceTopLevelContext()).not.toBeNull();
     expect(conversation.getWorkspaceTopLevelContext()!).toContain(
@@ -299,7 +302,7 @@ describe("Conversation workspace cache state", () => {
   test("renders client-reported host env when set on the conversation", () => {
     conversation.hostHomeDir = "/Users/alice";
     conversation.hostUsername = "alice";
-    conversation.refreshWorkspaceTopLevelContextIfNeeded();
+    refreshWorkspaceTopLevelContextIfNeeded(conversation);
 
     const block = conversation.getWorkspaceTopLevelContext();
     expect(block).not.toBeNull();
@@ -309,7 +312,7 @@ describe("Conversation workspace cache state", () => {
 
   test("falls back to daemon os info when client host env is absent", async () => {
     const { homedir, userInfo } = await import("node:os");
-    conversation.refreshWorkspaceTopLevelContextIfNeeded();
+    refreshWorkspaceTopLevelContextIfNeeded(conversation);
 
     const block = conversation.getWorkspaceTopLevelContext();
     expect(block).not.toBeNull();
@@ -320,7 +323,7 @@ describe("Conversation workspace cache state", () => {
   test("re-renders with updated host env after marking dirty", () => {
     conversation.hostHomeDir = "/Users/alice";
     conversation.hostUsername = "alice";
-    conversation.refreshWorkspaceTopLevelContextIfNeeded();
+    refreshWorkspaceTopLevelContextIfNeeded(conversation);
     expect(conversation.getWorkspaceTopLevelContext()!).toContain(
       "Host home directory: /Users/alice",
     );
@@ -328,7 +331,7 @@ describe("Conversation workspace cache state", () => {
     conversation.hostHomeDir = "/Users/bob";
     conversation.hostUsername = "bob";
     conversation.markWorkspaceTopLevelDirty();
-    conversation.refreshWorkspaceTopLevelContextIfNeeded();
+    refreshWorkspaceTopLevelContextIfNeeded(conversation);
 
     const block = conversation.getWorkspaceTopLevelContext();
     expect(block).not.toBeNull();
@@ -344,7 +347,7 @@ describe("Conversation workspace cache state", () => {
     // Simulate a macOS turn populating host env.
     conversation.hostHomeDir = "/Users/alice";
     conversation.hostUsername = "alice";
-    conversation.refreshWorkspaceTopLevelContextIfNeeded();
+    refreshWorkspaceTopLevelContextIfNeeded(conversation);
     expect(conversation.getWorkspaceTopLevelContext()!).toContain(
       "Host home directory: /Users/alice",
     );
@@ -355,7 +358,7 @@ describe("Conversation workspace cache state", () => {
     conversation.hostHomeDir = undefined;
     conversation.hostUsername = undefined;
     conversation.markWorkspaceTopLevelDirty();
-    conversation.refreshWorkspaceTopLevelContextIfNeeded();
+    refreshWorkspaceTopLevelContextIfNeeded(conversation);
 
     const block = conversation.getWorkspaceTopLevelContext();
     expect(block).not.toBeNull();
@@ -381,7 +384,7 @@ describe("Conversation workspace cache state", () => {
     expect(conversation.hostUsername).toBe("alice");
     expect(conversation.isWorkspaceTopLevelDirty()).toBe(true);
 
-    conversation.refreshWorkspaceTopLevelContextIfNeeded();
+    refreshWorkspaceTopLevelContextIfNeeded(conversation);
     const block = conversation.getWorkspaceTopLevelContext();
     expect(block!).toContain("Host home directory: /Users/alice");
     expect(block!).toContain("Host username: alice");
@@ -455,7 +458,7 @@ describe("Conversation workspace cache state", () => {
       hostUsername: "alice",
     });
     // Render once so the dirty flag clears.
-    conversation.refreshWorkspaceTopLevelContextIfNeeded();
+    refreshWorkspaceTopLevelContextIfNeeded(conversation);
     expect(conversation.isWorkspaceTopLevelDirty()).toBe(false);
 
     // Re-apply the same values — dirty flag should remain false so we don't
@@ -476,7 +479,7 @@ describe("Conversation workspace cache state", () => {
       hostHomeDir: "/Users/alice",
       hostUsername: "alice",
     });
-    conversation.refreshWorkspaceTopLevelContextIfNeeded();
+    refreshWorkspaceTopLevelContextIfNeeded(conversation);
     expect(conversation.isWorkspaceTopLevelDirty()).toBe(false);
 
     // New values — should mark dirty so the next render picks them up.
@@ -500,7 +503,7 @@ describe("Conversation workspace cache state", () => {
 
     try {
       const tempConversation = makeConversation(workspaceRoot);
-      tempConversation.refreshWorkspaceTopLevelContextIfNeeded();
+      refreshWorkspaceTopLevelContextIfNeeded(tempConversation);
 
       expect(tempConversation.getWorkspaceTopLevelContext()!).toContain(
         `Current conversation attachments: conversations/${legacyDirName}/attachments/`,

package/src/__tests__/conversation-workspace-injection.test.ts

@@ -144,7 +144,7 @@ mock.module("../memory/conversation-crud.js", () => ({
   getMessageById: () => null,
   getLastUserTimestampBefore: () => 0,
   setLastNotifiedInferenceProfile: () => {},
-  getConversationOverrideProfileFromRow: () => undefined,
+  resolveOverrideProfile: () => undefined,
   updateMessageMetadata: () => {},
   reserveMessage: mock(async () => ({ id: "msg-reserve" })),
   updateMessageContent: mock(() => {}),
@@ -181,8 +181,9 @@ mock.module("../memory/query-builder.js", () => ({
 mock.module("../memory/retrieval-budget.js", () => ({
   computeRecallBudget: () => 0,
 }));
-mock.module("../context/window-manager.js", () => ({
+mock.module("../plugins/defaults/compaction/window-manager.js", () => ({
   ContextWindowManager: class {
+    updateConfig() {}
     shouldCompact() {
       return { needed: false, estimatedTokens: 0 };
     }
@@ -244,10 +245,11 @@ mock.module("../agent/loop.js", () => ({
     getActiveModel() {
       return undefined;
     }
-    async run(
-      messages: Message[],
-      onEvent: (event: AgentEvent) => void,
-    ): Promise<AgentLoopRunResult> {
+    async run(options: {
+      messages: Message[];
+      onEvent: (event: AgentEvent) => void;
+    }): Promise<AgentLoopRunResult> {
+      const { messages, onEvent } = options;
       // Prime the assistant row anchor — production code emits this from
       // `AgentLoop.run` just before `provider.sendMessage`.
       await onEvent({ type: "llm_call_started" });
@@ -295,6 +297,14 @@ mock.module("../memory/canonical-guardian-store.js", () => ({
 }));
 
 import { Conversation } from "../daemon/conversation.js";
+import {
+  clearConversations,
+  findConversation,
+  removeSubagentConversation,
+  setConversation,
+  setSubagentConversation,
+} from "../daemon/conversation-registry.js";
+import { resolveWorkspaceTopLevelContext } from "../daemon/conversation-workspace.js";
 import { resetPluginRegistryAndRegisterDefaults } from "../plugins/defaults/index.js";
 
 function makeConversation(): Conversation {
@@ -309,7 +319,7 @@ function makeConversation(): Conversation {
       };
     },
   };
-  return new Conversation(
+  const conversation = new Conversation(
     "conv-1",
     provider,
     "system prompt",
@@ -317,6 +327,10 @@ function makeConversation(): Conversation {
     "/tmp",
     { maxTokens: 4096 },
   );
+  // Mirror production: top-level conversations are registered in the store, so
+  // the workspace injector can resolve them by id via the conversation registry.
+  setConversation(conversation.conversationId, conversation);
+  return conversation;
 }
 
 function messageText(message: Message): string {
@@ -335,6 +349,7 @@ describe("Conversation workspace injection", () => {
     runCalls = [];
     agentLoopScript = () => {};
     scanCallCount = 0;
+    clearConversations();
     resetPluginRegistryAndRegisterDefaults();
   });
 
@@ -417,11 +432,58 @@ describe("Conversation workspace injection", () => {
   });
 });
 
+describe("Conversation workspace injection — subagents", () => {
+  beforeEach(() => {
+    scanCallCount = 0;
+    clearConversations();
+    resetPluginRegistryAndRegisterDefaults();
+  });
+
+  test("workspace context resolves for subagent conversations not in the store", () => {
+    const provider = {
+      name: "mock",
+      async sendMessage(): Promise<ProviderResponse> {
+        return {
+          content: [],
+          model: "mock",
+          usage: { inputTokens: 0, outputTokens: 0 },
+          stopReason: "end_turn",
+        };
+      },
+    };
+    const subagentId = "subagent-conv-1";
+    const conversation = new Conversation(
+      subagentId,
+      provider,
+      "system prompt",
+      () => {},
+      "/tmp",
+      { maxTokens: 4096 },
+    );
+    setSubagentConversation(subagentId, conversation);
+
+    try {
+      // Subagents live only in the manager's index, never in the
+      // eviction-managed store, so the store lookup must not see them.
+      expect(findConversation(subagentId)).toBeUndefined();
+
+      // The per-conversation workspace lookup still resolves them, so subagent
+      // turns retain workspace grounding.
+      const context = resolveWorkspaceTopLevelContext(subagentId);
+      expect(context).not.toBeNull();
+      expect(context).toContain("Root: /tmp");
+    } finally {
+      removeSubagentConversation(subagentId, conversation);
+    }
+  });
+});
+
 describe("Conversation workspace dirty-refresh E2E", () => {
   beforeEach(() => {
     runCalls = [];
     agentLoopScript = () => {};
     scanCallCount = 0;
+    clearConversations();
     resetPluginRegistryAndRegisterDefaults();
   });
 

package/src/__tests__/conversation-workspace-tool-tracking.test.ts

@@ -141,7 +141,7 @@ mock.module("../memory/conversation-crud.js", () => ({
   getMessageById: () => null,
   getLastUserTimestampBefore: () => 0,
   setLastNotifiedInferenceProfile: () => {},
-  getConversationOverrideProfileFromRow: () => undefined,
+  resolveOverrideProfile: () => undefined,
   updateMessageMetadata: () => {},
   reserveMessage: mock(async () => ({ id: "msg-reserve" })),
   updateMessageContent: mock(() => {}),
@@ -178,8 +178,9 @@ mock.module("../memory/query-builder.js", () => ({
 mock.module("../memory/retrieval-budget.js", () => ({
   computeRecallBudget: () => 0,
 }));
-mock.module("../context/window-manager.js", () => ({
+mock.module("../plugins/defaults/compaction/window-manager.js", () => ({
   ContextWindowManager: class {
+    updateConfig() {}
     shouldCompact() {
       return { needed: false, estimatedTokens: 0 };
     }
@@ -228,10 +229,11 @@ mock.module("../agent/loop.js", () => ({
     getActiveModel() {
       return undefined;
     }
-    async run(
-      messages: Message[],
-      onEvent: (event: AgentEvent) => void,
-    ): Promise<Message[]> {
+    async run(options: {
+      messages: Message[];
+      onEvent: (event: AgentEvent) => void;
+    }): Promise<Message[]> {
+      const { messages, onEvent } = options;
       // Prime the assistant row anchor — production code emits this from
       // `AgentLoop.run` just before `provider.sendMessage`.
       await onEvent({ type: "llm_call_started" });
@@ -273,6 +275,7 @@ mock.module("../memory/canonical-guardian-store.js", () => ({
 }));
 
 import { Conversation } from "../daemon/conversation.js";
+import { refreshWorkspaceTopLevelContextIfNeeded } from "../daemon/conversation-workspace.js";
 
 function makeConversation(): Conversation {
   const provider = {
@@ -310,7 +313,7 @@ describe("Conversation workspace dirty on file mutations", () => {
     await conversation.loadFromDb();
 
     // Prime the cache so dirty=false
-    conversation.refreshWorkspaceTopLevelContextIfNeeded();
+    refreshWorkspaceTopLevelContextIfNeeded(conversation);
     expect(conversation.isWorkspaceTopLevelDirty()).toBe(false);
 
     agentLoopScript = (onEvent) => {
@@ -339,7 +342,7 @@ describe("Conversation workspace dirty on file mutations", () => {
     const conversation = makeConversation();
     await conversation.loadFromDb();
 
-    conversation.refreshWorkspaceTopLevelContextIfNeeded();
+    refreshWorkspaceTopLevelContextIfNeeded(conversation);
     expect(conversation.isWorkspaceTopLevelDirty()).toBe(false);
 
     agentLoopScript = (onEvent) => {
@@ -370,7 +373,7 @@ describe("Conversation workspace dirty on file mutations", () => {
     const conversation = makeConversation();
     await conversation.loadFromDb();
 
-    conversation.refreshWorkspaceTopLevelContextIfNeeded();
+    refreshWorkspaceTopLevelContextIfNeeded(conversation);
     expect(conversation.isWorkspaceTopLevelDirty()).toBe(false);
 
     agentLoopScript = (onEvent) => {
@@ -399,7 +402,7 @@ describe("Conversation workspace dirty on file mutations", () => {
     const conversation = makeConversation();
     await conversation.loadFromDb();
 
-    conversation.refreshWorkspaceTopLevelContextIfNeeded();
+    refreshWorkspaceTopLevelContextIfNeeded(conversation);
     expect(conversation.isWorkspaceTopLevelDirty()).toBe(false);
 
     agentLoopScript = (onEvent) => {
@@ -428,7 +431,7 @@ describe("Conversation workspace dirty on file mutations", () => {
     const conversation = makeConversation();
     await conversation.loadFromDb();
 
-    conversation.refreshWorkspaceTopLevelContextIfNeeded();
+    refreshWorkspaceTopLevelContextIfNeeded(conversation);
     expect(conversation.isWorkspaceTopLevelDirty()).toBe(false);
 
     agentLoopScript = (onEvent) => {
@@ -457,7 +460,7 @@ describe("Conversation workspace dirty on file mutations", () => {
     const conversation = makeConversation();
     await conversation.loadFromDb();
 
-    conversation.refreshWorkspaceTopLevelContextIfNeeded();
+    refreshWorkspaceTopLevelContextIfNeeded(conversation);
     expect(conversation.isWorkspaceTopLevelDirty()).toBe(false);
 
     agentLoopScript = (onEvent) => {

package/src/__tests__/conversations-import-system-filter.test.ts

@@ -0,0 +1,101 @@
+/**
+ * Tests that the conversations import route never persists non-renderable
+ * roles. The messages store is UI-facing (`ConversationMessage`), so an
+ * imported export carrying agent-context `system` rows must land only its
+ * `user`/`assistant` turns — the `system` rows are dropped, not persisted.
+ */
+
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+mock.module("../config/loader.js", () => ({
+  getConfig: () => ({
+    ui: {},
+    model: "test",
+    provider: "test",
+    memory: { enabled: false },
+    rateLimit: { maxRequestsPerMinute: 0 },
+  }),
+}));
+
+mock.module("../memory/indexer.js", () => ({
+  indexMessageNow: async () => {},
+}));
+
+import { getMessages } from "../memory/conversation-crud.js";
+import { getDb } from "../memory/db-connection.js";
+import { initializeDb } from "../memory/db-init.js";
+import { conversations, messages } from "../memory/schema.js";
+import { ROUTES } from "../runtime/routes/conversations-import-routes.js";
+import type { RouteHandlerArgs } from "../runtime/routes/types.js";
+
+initializeDb();
+
+function resetTables() {
+  const db = getDb();
+  db.run("DELETE FROM message_attachments");
+  db.run("DELETE FROM attachments");
+  db.run("DELETE FROM messages");
+  db.run("DELETE FROM conversation_keys");
+  db.run("DELETE FROM conversations");
+}
+
+const importHandler = ROUTES.find(
+  (r) => r.operationId === "conversations_import",
+)!.handler;
+
+describe("conversations import system-row filtering", () => {
+  beforeEach(resetTables);
+
+  test("imports renderable turns but drops system rows", async () => {
+    // GIVEN an export whose conversation sandwiches a system row between two
+    // renderable turns (e.g. agent-context scaffolding an export carried)
+    const body = {
+      conversations: [
+        {
+          sourceKey: "src-1",
+          title: "Imported chat",
+          messages: [
+            { role: "user", content: "first visible" },
+            { role: "system", content: "agent-context scaffolding" },
+            { role: "assistant", content: "second visible" },
+          ],
+        },
+      ],
+    };
+
+    // WHEN the conversation is imported
+    const result = (await importHandler({
+      body,
+    } as unknown as RouteHandlerArgs)) as {
+      ok: boolean;
+      imported: number;
+      messages: number;
+    };
+
+    // THEN the import succeeds and only counts the renderable turns
+    expect(result.ok).toBe(true);
+    expect(result.imported).toBe(1);
+    expect(result.messages).toBe(2);
+
+    // AND the persisted rows are exactly the user/assistant turns, never the
+    // system scaffolding
+    const db = getDb();
+    const conv = db.select().from(conversations).all()[0];
+    const rows = getMessages(conv.id);
+    expect(rows.map((m) => m.role)).toEqual(["user", "assistant"]);
+    expect(
+      db
+        .select()
+        .from(messages)
+        .all()
+        .some((m) => m.role === "system"),
+    ).toBe(false);
+  });
+});

package/src/__tests__/corrected-target.test.ts

@@ -0,0 +1,93 @@
+import { describe, expect, test } from "bun:test";
+
+import { computeCorrectedOverflowTarget } from "../plugins/defaults/compaction/corrected-target.js";
+
+describe("computeCorrectedOverflowTarget", () => {
+  test("lowers the target proportionally when the estimator under-counted", () => {
+    /**
+     * When the provider's actual token count exceeds the estimator's count,
+     * the target is scaled down by the estimation-error ratio so a re-estimate
+     * of the reduced history lands under the provider's real ceiling.
+     */
+    // GIVEN a preflight budget and an estimator that under-counted (185k vs 242k actual)
+    const preflightBudget = 162_000;
+    const actualTokens = 242_000;
+    const estimatedTokens = 185_000;
+
+    // WHEN computing the corrected target
+    const result = computeCorrectedOverflowTarget({
+      preflightBudget,
+      actualTokens,
+      estimatedTokens,
+    });
+
+    // THEN the target is the budget divided by the error ratio
+    const expectedRatio = actualTokens / estimatedTokens;
+    expect(result.targetTokens).toBe(
+      Math.floor(preflightBudget / expectedRatio),
+    );
+    // AND the ratio is surfaced for logging
+    expect(result.estimationErrorRatio).toBeCloseTo(expectedRatio, 10);
+    // AND the corrected target is below the nominal budget
+    expect(result.targetTokens).toBeLessThan(preflightBudget);
+  });
+
+  test("returns the preflight budget unchanged when the estimator did not under-count", () => {
+    /**
+     * If the estimator matched or over-counted the provider, no correction is
+     * applied and the nominal preflight budget is the target.
+     */
+    // GIVEN an actual count at or below the estimate
+    const preflightBudget = 162_000;
+
+    // WHEN computing the corrected target
+    const result = computeCorrectedOverflowTarget({
+      preflightBudget,
+      actualTokens: 180_000,
+      estimatedTokens: 185_000,
+    });
+
+    // THEN the target is the unchanged preflight budget and no ratio is reported
+    expect(result.targetTokens).toBe(preflightBudget);
+    expect(result.estimationErrorRatio).toBeNull();
+  });
+
+  test("falls back to the preflight budget when the actual count is unavailable", () => {
+    /**
+     * Proxy-rewrapped or unparseable rejections yield a null actual count; the
+     * correction is skipped rather than guessed.
+     */
+    // GIVEN a null actual token count
+    const preflightBudget = 162_000;
+
+    // WHEN computing the corrected target
+    const result = computeCorrectedOverflowTarget({
+      preflightBudget,
+      actualTokens: null,
+      estimatedTokens: 185_000,
+    });
+
+    // THEN the nominal budget is used with no ratio
+    expect(result.targetTokens).toBe(preflightBudget);
+    expect(result.estimationErrorRatio).toBeNull();
+  });
+
+  test("falls back to the preflight budget when the estimate is zero", () => {
+    /**
+     * A zero estimate would make the ratio undefined; guard against it.
+     */
+    // GIVEN a zero estimate
+    const preflightBudget = 162_000;
+
+    // WHEN computing the corrected target
+    const result = computeCorrectedOverflowTarget({
+      preflightBudget,
+      actualTokens: 242_000,
+      estimatedTokens: 0,
+    });
+
+    // THEN the nominal budget is used with no ratio
+    expect(result.targetTokens).toBe(preflightBudget);
+    expect(result.estimationErrorRatio).toBeNull();
+  });
+});

package/src/__tests__/credential-execution-feature-gates.test.ts

@@ -165,10 +165,11 @@ describe("CES flags do not affect unrelated flags", () => {
     setOverridesForTesting(overrides);
     const config = makeConfig();
 
-    // account-deletion defaults to true in the registry and should stay true.
-    expect(isAssistantFeatureFlagEnabled("account-deletion", config)).toBe(
-      true,
-    );
+    // Flags with defaultEnabled: true in the registry should stay true
+    // regardless of CES overrides.
+    expect(
+      isAssistantFeatureFlagEnabled("platform-features-in-local-mode", config),
+    ).toBe(true);
   });
 
   test("enabling all CES flags does not change unrelated fail-closed flags", () => {

package/src/__tests__/credential-security-invariants.test.ts

@@ -231,6 +231,7 @@ describe("Invariant 2: no generic plaintext secret read API", () => {
       "ipc/skill-routes/providers.ts", // host.providers.secureKeys.getProviderKey IPC route (out-of-process SkillHost companion)
       "daemon/external-plugins-bootstrap.ts", // reads credentials at plugin init (manifest.requiresCredential) via the CES-mediated getSecureKeyAsync path
       "plugins/external-api.ts", // globalThis runtime bridge that exposes getSecureKeyAsync to dynamically-imported workspace plugins (compiled-binary plugin loading)
+      "plugin-api/index.ts", // public @vellumai/plugin-api surface re-exports getSecureKeyAsync to workspace plugins via the boot-time shim (same exposure as the external-api bridge, routed through the typed public package)
       "inbound/platform-callback-registration.ts", // managed credential lookup for platform base URL, assistant ID, and API key
       "tts/providers/elevenlabs-provider.ts", // ElevenLabs TTS API key lookup
       "tts/providers/deepgram-provider.ts", // Deepgram TTS API key lookup

package/src/__tests__/cu-unified-flow.test.ts

@@ -69,6 +69,7 @@ type SurfaceConversationContext =
 function buildMockContext(
   hostCuProxy?: InstanceType<typeof HostCuProxy>,
   trustGuardianPrincipalId: string | null = DEFAULT_PRINCIPAL,
+  actorPrincipalId: string | null = trustGuardianPrincipalId,
 ): SurfaceConversationContext {
   return {
     conversationId: "test-session",
@@ -80,6 +81,16 @@ function buildMockContext(
             guardianPrincipalId: trustGuardianPrincipalId,
           }
         : undefined,
+    authContext:
+      actorPrincipalId != null
+        ? ({ actorPrincipalId } as SurfaceConversationContext["authContext"])
+        : undefined,
+    currentTurnAuthContext:
+      actorPrincipalId != null
+        ? ({
+            actorPrincipalId,
+          } as SurfaceConversationContext["currentTurnAuthContext"])
+        : undefined,
     traceEmitter: { emit: () => {} },
     sendToClient: () => {},
     pendingSurfaceActions: new Map(),
@@ -665,6 +676,31 @@ describe("surfaceProxyResolver — CU tool routing", () => {
       expect(sentMessages).toHaveLength(0);
     });
 
+    test("rejects untargeted CU dispatch to owner client when current requester is a trusted contact", async () => {
+      sentMessages.length = 0;
+      mockHasClient = true;
+      mockCuClients = [
+        {
+          clientId: "owner-cu-client",
+          capabilities: ["host_cu"],
+          actorPrincipalId: "owner-user",
+        },
+      ];
+      proxy = new HostCuProxy();
+      const ctx = buildMockContext(proxy, "owner-user", "trusted-contact-user");
+
+      const result = await surfaceProxyResolver(ctx, "computer_use_click", {
+        element_id: 1,
+        reasoning: "click",
+      });
+
+      expect(result.isError).toBe(true);
+      expect(result.content).toContain("current actor");
+      expect(proxy.stepCount).toBe(0);
+      expect(proxy.actionHistory).toHaveLength(0);
+      expect(sentMessages).toHaveLength(0);
+    });
+
     test("auto-resolves to the unique same-user CU client when cross-user clients are present", async () => {
       // Regression: previously the dispatch counted only same-user clients
       // for the multi-client guard, so 1 same-user + 1 cross-user passed the