@vellumai/assistant 0.7.2 → 0.8.0

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

@@ -1,4 +1,11 @@
-import { describe, expect, it } from "bun:test";
+import { beforeEach, describe, expect, it, mock } from "bun:test";
+
+let providerRoutingSources: Record<string, "user-key" | "managed-proxy"> = {};
+
+mock.module("../providers/registry.js", () => ({
+  getProviderRoutingSource: (provider: string) =>
+    providerRoutingSources[provider],
+}));
 
 import type { ErrorContext } from "../daemon/conversation-error.js";
 import {
@@ -63,6 +70,10 @@ describe("isUserCancellation", () => {
 describe("classifyConversationError", () => {
   const baseCtx: ErrorContext = { phase: "agent_loop" };
 
+  beforeEach(() => {
+    providerRoutingSources = {};
+  });
+
   describe("network errors", () => {
     const cases = [
       "ECONNREFUSED",
@@ -105,6 +116,52 @@ describe("classifyConversationError", () => {
         expect(result.errorCategory).toBe("rate_limit");
       });
     }
+
+    it("classifies managed-proxy daily quota responses as MANAGED_USAGE_LIMIT", () => {
+      const err = new ProviderError(
+        'Anthropic API error (429): 429 {"code":"daily_quota_exceeded","detail":"You\'ve reached your usage limit for today. You\'ve made 1000 requests, but your current plan allows 1000 per day.","provider":"anthropic"}',
+        "anthropic",
+        429,
+      );
+
+      const result = classifyConversationError(err, baseCtx);
+
+      expect(result.code).toBe("MANAGED_USAGE_LIMIT");
+      expect(result.retryable).toBe(true);
+      expect(result.userMessage).toContain("Vellum managed inference");
+      expect(result.userMessage).toContain("not an AI provider outage");
+      expect(result.errorCategory).toBe("managed_usage_limit");
+    });
+
+    it("classifies managed-proxy routed 429s as MANAGED_USAGE_LIMIT", () => {
+      providerRoutingSources.anthropic = "managed-proxy";
+      const err = new ProviderError(
+        "Anthropic API error (429): Too many requests",
+        "anthropic",
+        429,
+      );
+
+      const result = classifyConversationError(err, baseCtx);
+
+      expect(result.code).toBe("MANAGED_USAGE_LIMIT");
+      expect(result.userMessage).toContain("Vellum managed inference");
+      expect(result.errorCategory).toBe("managed_usage_limit");
+    });
+
+    it("keeps provider copy for direct provider 429s", () => {
+      providerRoutingSources.anthropic = "user-key";
+      const err = new ProviderError(
+        "Anthropic API error (429): Too many requests",
+        "anthropic",
+        429,
+      );
+
+      const result = classifyConversationError(err, baseCtx);
+
+      expect(result.code).toBe("PROVIDER_RATE_LIMIT");
+      expect(result.userMessage).toContain("AI provider");
+      expect(result.errorCategory).toBe("rate_limit");
+    });
   });
 
   describe("provider overloaded errors", () => {
@@ -509,11 +566,11 @@ describe("classifyConversationError", () => {
       expect(result.errorCategory).toBe("provider_not_configured");
     });
 
-    it("classifies ProviderError with 402 as credits_exhausted (non-retryable)", () => {
+    it("classifies direct ProviderError with 402 as provider_billing (non-retryable)", () => {
       const err = new ProviderError("Payment Required", "anthropic", 402);
       const result = classifyConversationError(err, baseCtx);
       expect(result.code).toBe("PROVIDER_BILLING");
-      expect(result.errorCategory).toBe("credits_exhausted");
+      expect(result.errorCategory).toBe("provider_billing");
       expect(result.retryable).toBe(false);
     });
 
@@ -560,6 +617,96 @@ describe("classifyConversationError", () => {
     });
   });
 
+  describe("OpenRouter billing classification", () => {
+    it("keeps managed-proxy OpenRouter 402 responses as credits_exhausted", () => {
+      providerRoutingSources.openrouter = "managed-proxy";
+      const err = new ProviderError(
+        "OpenRouter API error (402): Payment Required",
+        "openrouter",
+        402,
+      );
+
+      const result = classifyConversationError(err, baseCtx);
+
+      expect(result.code).toBe("PROVIDER_BILLING");
+      expect(result.errorCategory).toBe("credits_exhausted");
+      expect(result.retryable).toBe(false);
+      expect(result.userMessage).toContain("Add funds");
+      expect(result.userMessage).toContain("assistant");
+    });
+
+    it("classifies direct Anthropic, OpenAI, and OpenRouter 402 responses as provider_billing", () => {
+      providerRoutingSources.anthropic = "user-key";
+      providerRoutingSources.openai = "user-key";
+      providerRoutingSources.openrouter = "user-key";
+
+      for (const provider of ["anthropic", "openai", "openrouter"]) {
+        const err = new ProviderError(
+          `${provider} API error (402): Payment Required`,
+          provider,
+          402,
+        );
+
+        const result = classifyConversationError(err, baseCtx);
+
+        expect(result.code).toBe("PROVIDER_BILLING");
+        expect(result.errorCategory).toBe("provider_billing");
+        expect(result.retryable).toBe(false);
+        expect(result.userMessage).toContain("provider");
+        expect(result.userMessage).toContain("Settings");
+      }
+    });
+
+    it("classifies OpenRouter 400 credit-limit messages as provider_billing", () => {
+      const cases = [
+        "OpenRouter API error (400): This request requires more credits",
+        "OpenRouter API error (400): You can only afford 1000 tokens",
+      ];
+
+      for (const message of cases) {
+        const err = new ProviderError(message, "openrouter", 400);
+
+        const result = classifyConversationError(err, baseCtx);
+
+        expect(result.code).toBe("PROVIDER_BILLING");
+        expect(result.errorCategory).toBe("provider_billing");
+        expect(result.retryable).toBe(false);
+      }
+    });
+
+    it("classifies managed-proxy OpenRouter insufficient_balance bodies as credits_exhausted", () => {
+      providerRoutingSources.openrouter = "managed-proxy";
+      const err = new ProviderError(
+        'OpenRouter API error (402): {"code":"insufficient_balance","detail":"Managed balance exhausted"}',
+        "openrouter",
+        402,
+      );
+
+      const result = classifyConversationError(err, baseCtx);
+
+      expect(result.code).toBe("PROVIDER_BILLING");
+      expect(result.errorCategory).toBe("credits_exhausted");
+      expect(result.retryable).toBe(false);
+    });
+
+    it("classifies direct OpenRouter insufficient_balance bodies as provider_billing", () => {
+      providerRoutingSources.openrouter = "user-key";
+      const err = new ProviderError(
+        'OpenRouter API error (402): {"code":"insufficient_balance","detail":"Provider account balance exhausted"}',
+        "openrouter",
+        402,
+      );
+
+      const result = classifyConversationError(err, baseCtx);
+
+      expect(result.code).toBe("PROVIDER_BILLING");
+      expect(result.errorCategory).toBe("provider_billing");
+      expect(result.retryable).toBe(false);
+      expect(result.userMessage).toContain("provider");
+      expect(result.userMessage).toContain("Settings");
+    });
+  });
+
   describe("debug detail truncation", () => {
     it("truncates debugDetails longer than 4000 chars", () => {
       const longMsg = "x".repeat(5000);

package/src/__tests__/conversation-init.benchmark.test.ts

@@ -465,7 +465,7 @@ describe("End-to-end session creation benchmark", () => {
       timings.push(performance.now() - start);
 
       if (i === 0) {
-        expect(session.eventBus.listenerCount()).toBeGreaterThan(0);
+        expect(session.eventBus.anyListenerCount()).toBeGreaterThan(0);
       }
       session.dispose();
     }

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

@@ -77,6 +77,7 @@ mock.module("../config/loader.js", () => ({
       pricingOverrides: [],
     },
     rateLimit: { maxRequestsPerMinute: 0 },
+    memory: { v2: { enabled: false } },
     daemon: {
       startupSocketWaitMs: 5000,
       stopTimeoutMs: 5000,
@@ -382,4 +383,41 @@ describe("processMessage callSite threading", () => {
     expect(captured.resolvedMaxTokens).toBe(1234);
     expect(captured.resolvedHasMaxTokens).toBe(true);
   });
+
+  test("applies clientTimezone in the create and reuse transport metadata path", async () => {
+    mockConversation = {
+      id: "conv-store-client-timezone",
+      contextSummary: null,
+      contextCompactedMessageCount: 0,
+      totalInputTokens: 0,
+      totalOutputTokens: 0,
+      totalEstimatedCost: 0,
+    };
+    mockDbMessages = [];
+    clearCaptured();
+    clearAllActiveConversations();
+
+    const conversation = await getOrCreateConversation(
+      "conv-store-client-timezone",
+      {
+        transport: {
+          channelId: "vellum",
+          interfaceId: "macos",
+          clientTimezone: "america/new_york",
+        },
+      },
+    );
+
+    expect(conversation.clientTimezone).toBe("America/New_York");
+
+    await getOrCreateConversation("conv-store-client-timezone", {
+      transport: {
+        channelId: "vellum",
+        interfaceId: "ios",
+        clientTimezone: "europe/london",
+      },
+    });
+
+    expect(conversation.clientTimezone).toBe("Europe/London");
+  });
 });

package/src/__tests__/conversation-provider-retry-repair.test.ts

@@ -57,6 +57,7 @@ mock.module("../config/loader.js", () => ({
       pricingOverrides: [],
     },
     rateLimit: { maxRequestsPerMinute: 0 },
+    memory: { v2: { enabled: false } },
     services: {
       inference: {
         mode: "your-own",

package/src/__tests__/conversation-runtime-assembly.test.ts

@@ -1,5 +1,21 @@
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
+// This test exercises v1 PKB injection. `config.memory.v2.enabled` (default
+// `true`) makes the PKB injector go silent — force it off here so the v1
+// injection chain assertions stay meaningful.
+const realLoaderForAssemblyTest = await import("../config/loader.js");
+const realGetConfigForAssemblyTest = realLoaderForAssemblyTest.getConfig;
+mock.module("../config/loader.js", () => ({
+  ...realLoaderForAssemblyTest,
+  getConfig: () => {
+    const real = realGetConfigForAssemblyTest();
+    return {
+      ...real,
+      memory: { ...real.memory, v2: { ...real.memory.v2, enabled: false } },
+    };
+  },
+}));
+
 // PKB search is mocked so the reminder-hints tests can assert behavior
 // without standing up Qdrant. The mock returns whatever is staged in
 // `pkbSearchResults` / `pkbSearchThrows` for the enclosing test.
@@ -1430,6 +1446,64 @@ describe("buildUnifiedTurnContextBlock", () => {
     expect(text).toContain("time_since_last_message: yesterday");
     expect(text).toContain("canonical_actor_identity: user-1");
   });
+
+  test("timezone mismatch: omits extra lines when there is no manual override", () => {
+    const text = buildUnifiedTurnContextBlock({
+      timestamp: "2026-04-02 (Thursday) 08:00:00 -04:00 (America/New_York)",
+      clientTimezone: "America/New_York",
+      detectedTimezone: "America/New_York",
+    });
+
+    expect(text).toContain(
+      "current_time: 2026-04-02 (Thursday) 08:00:00 -04:00 (America/New_York)",
+    );
+    expect(text).not.toContain("configured_user_timezone:");
+    expect(text).not.toContain("client_device_timezone:");
+    expect(text).not.toContain("timezone_update_available:");
+  });
+
+  test("timezone mismatch: omits extra lines when configured and client timezone match", () => {
+    const text = buildUnifiedTurnContextBlock({
+      timestamp: "2026-04-02 (Thursday) 08:00:00 -04:00 (America/New_York)",
+      configuredUserTimezone: "America/New_York",
+      clientTimezone: "America/New_York",
+      detectedTimezone: "America/New_York",
+    });
+
+    expect(text).not.toContain("configured_user_timezone:");
+    expect(text).not.toContain("client_device_timezone:");
+    expect(text).not.toContain("timezone_update_available:");
+  });
+
+  test("timezone mismatch: emits configured and client device timezone when they differ", () => {
+    const text = buildUnifiedTurnContextBlock({
+      timestamp: "2026-04-02 (Thursday) 08:00:00 -04:00 (America/New_York)",
+      configuredUserTimezone: "America/New_York",
+      clientTimezone: "America/Los_Angeles",
+      detectedTimezone: "America/Los_Angeles",
+    });
+
+    expect(text).toContain("configured_user_timezone: America/New_York");
+    expect(text).toContain("client_device_timezone: America/Los_Angeles");
+  });
+
+  test("timezone mismatch: emits CLI affordance only in mismatch case", () => {
+    const mismatchText = buildUnifiedTurnContextBlock({
+      timestamp: "2026-04-02 (Thursday) 08:00:00 -04:00 (America/New_York)",
+      configuredUserTimezone: "America/New_York",
+      clientTimezone: "America/Los_Angeles",
+    });
+    const matchingText = buildUnifiedTurnContextBlock({
+      timestamp: "2026-04-02 (Thursday) 08:00:00 -04:00 (America/New_York)",
+      configuredUserTimezone: "America/New_York",
+      clientTimezone: "America/New_York",
+    });
+
+    expect(mismatchText).toContain(
+      'timezone_update_available: after explicit user confirmation, persist client_device_timezone with `assistant config set ui.userTimezone "America/Los_Angeles"`',
+    );
+    expect(matchingText).not.toContain("timezone_update_available:");
+  });
 });
 
 // ---------------------------------------------------------------------------

package/src/__tests__/conversation-slash-unknown.test.ts

@@ -60,6 +60,7 @@ mock.module("../config/loader.js", () => ({
       pricingOverrides: [],
     },
     rateLimit: { maxRequestsPerMinute: 0 },
+    memory: { v2: { enabled: false } },
     daemon: {
       startupSocketWaitMs: 5000,
       stopTimeoutMs: 5000,

package/src/__tests__/conversation-speed-override.test.ts

@@ -294,7 +294,6 @@ describe("per-conversation speed override", () => {
       4096,
       makeSendToClient(),
       "/tmp",
-      undefined, // memoryPolicy
       undefined, // sharedCesClient
       "standard", // speedOverride
     );
@@ -315,7 +314,6 @@ describe("per-conversation speed override", () => {
       4096,
       makeSendToClient(),
       "/tmp",
-      undefined, // memoryPolicy
       undefined, // sharedCesClient
       // no speedOverride — should fall back to global config "fast"
     );
@@ -335,7 +333,6 @@ describe("per-conversation speed override", () => {
       4096,
       makeSendToClient(),
       "/tmp",
-      undefined, // memoryPolicy
       undefined, // sharedCesClient
       "fast", // speedOverride
     );

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

@@ -19,7 +19,6 @@ import {
   createConversation,
   deleteLastExchange,
   getConversation,
-  getConversationMemoryScopeId,
   getMessages,
 } from "../memory/conversation-crud.js";
 import { isLastUserMessageToolResult } from "../memory/conversation-queries.js";
@@ -454,23 +453,6 @@ describe("createConversation with conversation type option", () => {
   });
 });
 
-describe("conversation metadata read helpers", () => {
-  beforeEach(() => {
-    const db = getDb();
-    db.run(`DELETE FROM messages`);
-    db.run(`DELETE FROM conversations`);
-  });
-
-  test("getConversationMemoryScopeId returns default for standard conversation", () => {
-    const conv = createConversation("test");
-    expect(getConversationMemoryScopeId(conv.id)).toBe("default");
-  });
-
-  test("getConversationMemoryScopeId returns default for missing conversation", () => {
-    expect(getConversationMemoryScopeId("nonexistent-id")).toBe("default");
-  });
-});
-
 // ---------------------------------------------------------------------------
 // Baseline: attachment reuse across conversations
 // ---------------------------------------------------------------------------

package/src/__tests__/conversation-surfaces-action-delivery.test.ts

@@ -1,13 +1,19 @@
-import { describe, expect, test } from "bun:test";
-
-import {
-  createSurfaceMutex,
-  handleSurfaceAction,
-  type SurfaceConversationContext,
-  surfaceProxyResolver,
-} from "../daemon/conversation-surfaces.js";
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+import type { ServerMessage } from "../daemon/message-protocol.js";
+
+let broadcastedMessages: ServerMessage[] = [];
+const realEventHub = await import("../runtime/assistant-event-hub.js");
+mock.module("../runtime/assistant-event-hub.js", () => ({
+  ...realEventHub,
+  broadcastMessage: (msg: ServerMessage) => broadcastedMessages.push(msg),
+}));
+
+const { createSurfaceMutex, handleSurfaceAction, surfaceProxyResolver } =
+  await import("../daemon/conversation-surfaces.js");
+
+import type { SurfaceConversationContext } from "../daemon/conversation-surfaces.js";
 import type {
-  ServerMessage,
   SurfaceData,
   SurfaceType,
   UiSurfaceShow,
@@ -81,6 +87,10 @@ function makeContext(sent: ServerMessage[] = []): SurfaceConversationContext & {
 }
 
 describe("surface action delivery to assistant", () => {
+  beforeEach(() => {
+    broadcastedMessages = [];
+  });
+
   test("table action button click triggers processMessage with action content", async () => {
     const sent: ServerMessage[] = [];
     const ctx = makeContext(sent);
@@ -199,4 +209,155 @@ describe("surface action delivery to assistant", () => {
       "[User action on app:",
     );
   });
+
+  test("confirmation surface broadcasts ui_surface_complete on action", async () => {
+    const sent: ServerMessage[] = [];
+    const ctx = makeContext(sent);
+
+    const showResult = await surfaceProxyResolver(ctx, "ui_show", {
+      surface_type: "confirmation",
+      title: "Delete files?",
+      data: {
+        message: "This will permanently delete 3 files.",
+        confirmLabel: "Delete",
+        cancelLabel: "Keep",
+      },
+    });
+
+    expect(showResult.isError).toBe(false);
+    expect(showResult.yieldToUser).toBe(true);
+
+    const showMessage = sent.find(
+      (msg): msg is UiSurfaceShow => msg.type === "ui_surface_show",
+    ) as UiSurfaceShow;
+    const surfaceId = showMessage.surfaceId;
+    expect(ctx.pendingSurfaceActions.has(surfaceId)).toBe(true);
+
+    await handleSurfaceAction(ctx, surfaceId, "confirm", {});
+
+    const completeMsg = broadcastedMessages.find(
+      (m) =>
+        (m as unknown as Record<string, unknown>).type ===
+          "ui_surface_complete" &&
+        (m as unknown as Record<string, unknown>).surfaceId === surfaceId,
+    ) as unknown as Record<string, unknown> | undefined;
+    expect(completeMsg).toBeDefined();
+    expect(completeMsg?.conversationId).toBe("conv-1");
+    expect(completeMsg?.summary).toContain("Delete");
+  });
+
+  test("file_upload surface broadcasts ui_surface_complete on action", async () => {
+    const sent: ServerMessage[] = [];
+    const ctx = makeContext(sent);
+
+    const showResult = await surfaceProxyResolver(ctx, "ui_show", {
+      surface_type: "file_upload",
+      title: "Upload documents",
+      data: { accept: ".pdf,.docx", maxFiles: 5 },
+    });
+
+    expect(showResult.isError).toBe(false);
+    expect(showResult.yieldToUser).toBe(true);
+
+    const showMessage = sent.find(
+      (msg): msg is UiSurfaceShow => msg.type === "ui_surface_show",
+    ) as UiSurfaceShow;
+    const surfaceId = showMessage.surfaceId;
+    expect(ctx.pendingSurfaceActions.has(surfaceId)).toBe(true);
+
+    await handleSurfaceAction(ctx, surfaceId, "submit", {
+      files: [
+        {
+          filename: "doc.pdf",
+          mimeType: "application/pdf",
+          data: "base64encodedcontent",
+        },
+      ],
+    });
+
+    const completeMsg = broadcastedMessages.find(
+      (m) =>
+        (m as unknown as Record<string, unknown>).type ===
+          "ui_surface_complete" &&
+        (m as unknown as Record<string, unknown>).surfaceId === surfaceId,
+    ) as unknown as Record<string, unknown> | undefined;
+    expect(completeMsg).toBeDefined();
+    expect(completeMsg?.conversationId).toBe("conv-1");
+  });
+
+  test("file_upload completion event does not include base64 file blobs", async () => {
+    const sent: ServerMessage[] = [];
+    const ctx = makeContext(sent);
+
+    await surfaceProxyResolver(ctx, "ui_show", {
+      surface_type: "file_upload",
+      title: "Upload",
+      data: { accept: "*" },
+    });
+
+    const showMessage = sent.find(
+      (msg): msg is UiSurfaceShow => msg.type === "ui_surface_show",
+    ) as UiSurfaceShow;
+    const surfaceId = showMessage.surfaceId;
+
+    const largeBase64 = "A".repeat(10_000);
+    await handleSurfaceAction(ctx, surfaceId, "submit", {
+      files: [
+        {
+          filename: "big.pdf",
+          mimeType: "application/pdf",
+          data: largeBase64,
+        },
+      ],
+    });
+
+    const completeMsg = broadcastedMessages.find(
+      (m) =>
+        (m as unknown as Record<string, unknown>).type ===
+          "ui_surface_complete" &&
+        (m as unknown as Record<string, unknown>).surfaceId === surfaceId,
+    ) as unknown as Record<string, unknown> | undefined;
+    expect(completeMsg).toBeDefined();
+
+    const submittedData = completeMsg?.submittedData as
+      | Record<string, unknown>
+      | undefined;
+    // The files array with base64 blobs should be stripped from the
+    // completion event — only the sanitized payload (without files) is sent.
+    expect(submittedData?.files).toBeUndefined();
+    // The raw base64 content should not appear anywhere in the event
+    expect(JSON.stringify(completeMsg)).not.toContain(largeBase64);
+  });
+
+  test("table surface does NOT broadcast ui_surface_complete (not one-shot)", async () => {
+    const sent: ServerMessage[] = [];
+    const ctx = makeContext(sent);
+
+    await surfaceProxyResolver(ctx, "ui_show", {
+      surface_type: "table",
+      title: "Items",
+      data: {
+        columns: [{ id: "name", label: "Name" }],
+        rows: [{ id: "r1", cells: { name: "Item 1" } }],
+      },
+      actions: [{ id: "select", label: "Select" }],
+    });
+
+    const showMessage = sent.find(
+      (msg): msg is UiSurfaceShow => msg.type === "ui_surface_show",
+    ) as UiSurfaceShow;
+    const surfaceId = showMessage.surfaceId;
+
+    broadcastedMessages = [];
+    await handleSurfaceAction(ctx, surfaceId, "select", {
+      selectedIds: ["r1"],
+    });
+
+    const completeMsg = broadcastedMessages.find(
+      (m) =>
+        (m as unknown as Record<string, unknown>).type ===
+        "ui_surface_complete",
+    );
+    expect(completeMsg).toBeUndefined();
+  });
 });

package/src/__tests__/conversation-surfaces-app-control.test.ts

@@ -33,8 +33,11 @@ mock.module("../runtime/pending-interactions.js", () => ({
 
 const { surfaceProxyResolver } =
   await import("../daemon/conversation-surfaces.js");
-const { HostAppControlProxy, _resetActiveAppControlConversationId } =
-  await import("../daemon/host-app-control-proxy.js");
+const {
+  HostAppControlProxy,
+  _resetActiveAppControlSession,
+  _setActiveAppControlSession,
+} = await import("../daemon/host-app-control-proxy.js");
 type SurfaceConversationContext =
   import("../daemon/conversation-surfaces.js").SurfaceConversationContext;
 
@@ -83,11 +86,11 @@ describe("surfaceProxyResolver — app-control tool routing", () => {
   beforeEach(() => {
     sentMessages.length = 0;
     mockHasClient = true;
-    _resetActiveAppControlConversationId();
+    _resetActiveAppControlSession();
   });
 
   afterEach(() => {
-    _resetActiveAppControlConversationId();
+    _resetActiveAppControlSession();
   });
 
   // -------------------------------------------------------------------------
@@ -148,6 +151,10 @@ describe("surfaceProxyResolver — app-control tool routing", () => {
     test("app_control_observe routes through proxy and returns observation", async () => {
       const proxy = new HostAppControlProxy("conv-1");
       const ctx = buildMockContext(proxy, "conv-1");
+      _setActiveAppControlSession({
+        conversationId: "conv-1",
+        app: "com.example.editor",
+      });
 
       const resultPromise = surfaceProxyResolver(ctx, "app_control_observe", {
         tool: "observe",
@@ -254,6 +261,10 @@ describe("surfaceProxyResolver — app-control tool routing", () => {
     test("injects `tool` derived from toolName when the agent input omits it", async () => {
       const proxy = new HostAppControlProxy("conv-1");
       const ctx = buildMockContext(proxy, "conv-1");
+      _setActiveAppControlSession({
+        conversationId: "conv-1",
+        app: "com.example.editor",
+      });
 
       // Agent inputs do not carry the discriminator — the resolver has to
       // synthesize it from `toolName` ("app_control_observe" → "observe")