@vellumai/assistant 0.8.1 → 0.8.2

package/src/__tests__/handlers-skills-memory-v2-reseed.test.ts

@@ -3,18 +3,13 @@
  * `assistant/src/daemon/handlers/skills.ts`.
  *
  * One representative call site (the `installSkill` bundled branch) is
- * exercised — all 5 sites share the same delegation to
- * `maybeSeedMemoryV2Skills`, so a single suite covers behavior. Validates:
- *   - config on → helper invoked after seedSkillGraphNodes and the seed
- *     observed (callOrder picks up "v2")
- *   - config off → helper still invoked, but the seed short-circuits
+ * exercised; all handler seed sites share the same delegation to
+ * `refreshSkillCapabilityMemories`, so a single suite covers behavior. Validates:
+ *   - handler invokes the centralized refresh helper with the live config.
  *
- * The handler delegates to `maybeSeedMemoryV2Skills` from
- * `daemon/memory-v2-startup.ts`. We mock that module directly so the test
- * does not have to drain the dynamic-import microtask chain. The helper's
- * gate semantics are covered by `lifecycle-memory-v2-seed.test.ts`; here
- * we only verify that the handler invokes the helper synchronously with
- * the live config.
+ * The helper's gate semantics (flag + config + rejection swallowing) are
+ * covered by `lifecycle-memory-v2-seed.test.ts`; here we only verify that the
+ * handler delegates to the centralized refresh path synchronously.
  */
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
@@ -22,16 +17,9 @@ import { beforeEach, describe, expect, mock, test } from "bun:test";
 // Programmable test state
 // ---------------------------------------------------------------------------
 
-const flagsState = { configV2Enabled: true };
+const configState = { v2Enabled: true };
 
-const callOrder: string[] = [];
-
-const mockSeedSkillGraphNodes = mock(() => {
-  callOrder.push("v1");
-});
-// Body installed in `beforeEach` so each test sees a fresh implementation
-// that closes over the up-to-date `flagsState`.
-const mockMaybeSeedMemoryV2Skills = mock(
+const mockRefreshSkillCapabilityMemories = mock(
   (_config: { memory: { v2: { enabled: boolean } } }) => {},
 );
 
@@ -53,10 +41,6 @@ mock.module("../config/skills.js", () => ({
   ],
 }));
 
-mock.module("../config/assistant-feature-flags.js", () => ({
-  isAssistantFeatureFlagEnabled: () => true,
-}));
-
 // Stub both `getConfig` and `loadConfig`. `loadConfig` is reached by code
 // paths transitively imported during teardown (e.g. dynamic imports inside
 // `oauth2.ts`); leaving it undefined here would break sibling test files
@@ -68,13 +52,13 @@ mock.module("../config/loader.js", () => ({
   deepMergeOverwrite: (a: unknown) => a,
   mergeDefaultWorkspaceConfig: () => {},
   getConfig: () => ({
-    memory: { v2: { enabled: flagsState.configV2Enabled } },
+    memory: { v2: { enabled: configState.v2Enabled } },
   }),
   getConfigReadOnly: () => ({
-    memory: { v2: { enabled: flagsState.configV2Enabled } },
+    memory: { v2: { enabled: configState.v2Enabled } },
   }),
   loadConfig: () => ({
-    memory: { v2: { enabled: flagsState.configV2Enabled } },
+    memory: { v2: { enabled: configState.v2Enabled } },
   }),
   invalidateConfigCache: () => {},
   loadRawConfig: () => ({}),
@@ -147,9 +131,11 @@ mock.module("../skills/catalog-cache.js", () => ({
 }));
 
 mock.module("../skills/catalog-install.js", () => ({
-  installSkillLocally: async () => {},
-  upsertSkillsIndex: () => {},
+  commitStagedSkillInstall: () => {},
+  createSkillInstallStagingDir: () => "/tmp/test-skills/.install-staging/test",
   getRepoSkillsDir: () => undefined,
+  installSkillDependenciesIfPresent: () => {},
+  installSkillLocally: async () => {},
 }));
 
 mock.module("../skills/catalog-search.js", () => ({
@@ -159,23 +145,15 @@ mock.module("../skills/catalog-search.js", () => ({
 mock.module("../skills/managed-store.js", () => ({
   createManagedSkill: () => ({ created: true }),
   deleteManagedSkill: () => ({ deleted: true }),
-  removeSkillsIndexEntry: () => {},
   validateManagedSkillId: () => null,
 }));
 
 mock.module("../memory/graph/capability-seed.js", () => ({
   deleteSkillCapabilityNode: () => {},
-  seedSkillGraphNodes: mockSeedSkillGraphNodes,
-  seedUninstalledCatalogSkillMemories: async () => {},
-}));
-
-mock.module("../memory/v2/skill-store.js", () => ({
-  seedV2SkillEntries: mock(async () => {}),
-  getSkillCapability: () => null,
 }));
 
-mock.module("../daemon/memory-v2-startup.js", () => ({
-  maybeSeedMemoryV2Skills: mockMaybeSeedMemoryV2Skills,
+mock.module("../daemon/skill-memory-refresh.js", () => ({
+  refreshSkillCapabilityMemories: mockRefreshSkillCapabilityMemories,
 }));
 
 mock.module("../util/platform.js", () => ({
@@ -204,45 +182,48 @@ mock.module("../daemon/config-watcher.js", () => ({
 }));
 
 // Import after mocking
-const { installSkill } = await import("../daemon/handlers/skills.js");
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
+const { installSkill, uninstallSkill } =
+  await import("../daemon/handlers/skills.js");
 
 // ---------------------------------------------------------------------------
 // Tests
 // ---------------------------------------------------------------------------
 
-describe("v2 skill re-seed gating in skill handlers", () => {
+describe("v2 skill refresh delegation in skill handlers", () => {
   beforeEach(() => {
-    flagsState.configV2Enabled = true;
-    callOrder.length = 0;
-    mockSeedSkillGraphNodes.mockClear();
-    mockMaybeSeedMemoryV2Skills.mockClear();
-    mockMaybeSeedMemoryV2Skills.mockImplementation((config) => {
-      if (!config.memory.v2.enabled) return;
-      callOrder.push("v2");
-    });
+    configState.v2Enabled = true;
+    mockRefreshSkillCapabilityMemories.mockClear();
   });
 
-  test("config on → maybeSeedMemoryV2Skills invoked after seedSkillGraphNodes", async () => {
+  test("enabled config → refresh helper invoked with live config", async () => {
     const result = await installSkill({ slug: "bundled-skill" });
 
     expect(result.success).toBe(true);
-    expect(mockSeedSkillGraphNodes).toHaveBeenCalledTimes(1);
-    expect(mockMaybeSeedMemoryV2Skills).toHaveBeenCalledTimes(1);
-    expect(callOrder).toEqual(["v1", "v2"]);
+    expect(mockRefreshSkillCapabilityMemories).toHaveBeenCalledTimes(1);
+    expect(mockRefreshSkillCapabilityMemories.mock.calls[0]?.[0]).toEqual({
+      memory: { v2: { enabled: true } },
+    });
   });
 
-  test("config.memory.v2.enabled off → seed mock observes config and skips", async () => {
-    flagsState.configV2Enabled = false;
+  test("config.memory.v2.enabled off → helper receives disabled config", async () => {
+    configState.v2Enabled = false;
 
     const result = await installSkill({ slug: "bundled-skill" });
 
     expect(result.success).toBe(true);
-    expect(mockSeedSkillGraphNodes).toHaveBeenCalledTimes(1);
-    expect(mockMaybeSeedMemoryV2Skills).toHaveBeenCalledTimes(1);
-    expect(callOrder).toEqual(["v1"]);
+    expect(mockRefreshSkillCapabilityMemories).toHaveBeenCalledTimes(1);
+    expect(mockRefreshSkillCapabilityMemories.mock.calls[0]?.[0]).toEqual({
+      memory: { v2: { enabled: false } },
+    });
+  });
+
+  test("uninstall delegates to refresh helper", async () => {
+    const result = await uninstallSkill("managed-skill");
+
+    expect(result.success).toBe(true);
+    expect(mockRefreshSkillCapabilityMemories).toHaveBeenCalledTimes(1);
+    expect(mockRefreshSkillCapabilityMemories.mock.calls[0]?.[0]).toEqual({
+      memory: { v2: { enabled: true } },
+    });
   });
 });

package/src/__tests__/helpers/tar-fixtures.ts

@@ -0,0 +1,39 @@
+export function makeTarEntry(name: string, content: string): Buffer {
+  const header = Buffer.alloc(512, 0);
+  const nameBuffer = Buffer.from(name, "utf-8");
+  nameBuffer.copy(header, 0, 0, Math.min(nameBuffer.length, 100));
+
+  Buffer.from("0000644\0", "ascii").copy(header, 100);
+  Buffer.from("0000000\0", "ascii").copy(header, 108);
+  Buffer.from("0000000\0", "ascii").copy(header, 116);
+  Buffer.from(
+    `${content.length.toString(8).padStart(11, "0")}\0`,
+    "ascii",
+  ).copy(header, 124);
+  Buffer.from("00000000000\0", "ascii").copy(header, 136);
+  Buffer.from("        ", "ascii").copy(header, 148);
+  header[156] = "0".charCodeAt(0);
+  Buffer.from("ustar\0", "ascii").copy(header, 257);
+  Buffer.from("00", "ascii").copy(header, 263);
+
+  let sum = 0;
+  for (let i = 0; i < 512; i += 1) sum += header[i] ?? 0;
+  Buffer.from(`${sum.toString(8).padStart(6, "0")}\0 `, "ascii").copy(
+    header,
+    148,
+  );
+
+  const data = Buffer.from(content, "utf-8");
+  const padded = Buffer.alloc(Math.ceil(data.length / 512) * 512, 0);
+  data.copy(padded);
+  return Buffer.concat([header, padded]);
+}
+
+export function makeTar(
+  entries: Array<{ name: string; content: string }>,
+): Buffer {
+  return Buffer.concat([
+    ...entries.map((entry) => makeTarEntry(entry.name, entry.content)),
+    Buffer.alloc(1024, 0),
+  ]);
+}

package/src/__tests__/helpers/wait-for.ts

@@ -0,0 +1,21 @@
+export async function waitFor(
+  predicate: () => boolean | Promise<boolean>,
+  options: {
+    timeoutMs?: number;
+    intervalMs?: number;
+    message?: string;
+  } = {},
+): Promise<void> {
+  const timeoutMs = options.timeoutMs ?? 500;
+  const intervalMs = options.intervalMs ?? 5;
+  const deadline = Date.now() + timeoutMs;
+
+  while (Date.now() < deadline) {
+    if (await predicate()) {
+      return;
+    }
+    await new Promise((resolve) => setTimeout(resolve, intervalMs));
+  }
+
+  throw new Error(options.message ?? "Timed out waiting for test condition");
+}

package/src/__tests__/history-repair-pipeline.test.ts

@@ -248,7 +248,6 @@ describe("historyRepair pipeline — end-to-end via runPipeline", () => {
       manifest: {
         name: "observer-plugin",
         version: "0.0.1",
-        requires: { pluginRuntime: "v1", historyRepairApi: "v1" },
       },
       middleware: { historyRepair: observer },
     });
@@ -297,7 +296,6 @@ describe("historyRepair pipeline — end-to-end via runPipeline", () => {
       manifest: {
         name: "override-plugin",
         version: "0.0.1",
-        requires: { pluginRuntime: "v1", historyRepairApi: "v1" },
       },
       middleware: { historyRepair: shortCircuit },
     });
@@ -342,7 +340,6 @@ describe("historyRepair pipeline — end-to-end via runPipeline", () => {
       manifest: {
         name: "late-user-plugin",
         version: "0.0.1",
-        requires: { pluginRuntime: "v1", historyRepairApi: "v1" },
       },
       middleware: { historyRepair: userMiddleware },
     });

package/src/__tests__/history-repair.test.ts

@@ -766,6 +766,79 @@ describe("repairHistory", () => {
         (b as { text: string }).text.includes("srvtoolu_orphan"),
     );
     expect(downgraded).toBeDefined();
+    // Titles/URLs from the original results must survive the downgrade so
+    // the model can still reason about what was searched.
+    const text = (downgraded as { text: string }).text;
+    expect(text).toContain("Example");
+    expect(text).toContain("https://example.com");
+  });
+
+  test("preserves all titles/URLs when downgrading multi-result orphan", () => {
+    const messages: Message[] = [
+      { role: "user", content: [{ type: "text", text: "search" }] },
+      {
+        role: "assistant",
+        content: [
+          {
+            type: "web_search_tool_result",
+            tool_use_id: "srvtoolu_multi",
+            content: [
+              {
+                type: "web_search_result",
+                url: "https://alpha.test",
+                title: "Alpha",
+                encrypted_content: "enc_a",
+              },
+              {
+                type: "web_search_result",
+                url: "https://beta.test",
+                title: "Beta",
+                encrypted_content: "enc_b",
+              },
+            ],
+          },
+        ],
+      },
+    ];
+
+    const { messages: repaired } = repairHistory(messages);
+    const downgraded = repaired[1].content.find((b) => b.type === "text") as
+      | { text: string }
+      | undefined;
+    expect(downgraded).toBeDefined();
+    expect(downgraded!.text).toContain("Alpha");
+    expect(downgraded!.text).toContain("https://alpha.test");
+    expect(downgraded!.text).toContain("Beta");
+    expect(downgraded!.text).toContain("https://beta.test");
+    // Must NOT emit the legacy fixed placeholder.
+    expect(downgraded!.text).not.toContain("[web search result]");
+  });
+
+  test("downgrades error-envelope web_search orphan to a stable marker", () => {
+    const messages: Message[] = [
+      { role: "user", content: [{ type: "text", text: "search" }] },
+      {
+        role: "assistant",
+        content: [
+          {
+            type: "web_search_tool_result",
+            tool_use_id: "srvtoolu_err",
+            content: {
+              type: "web_search_tool_result_error",
+              error_code: "unavailable",
+            },
+          },
+        ],
+      },
+    ];
+
+    const { messages: repaired } = repairHistory(messages);
+    const downgraded = repaired[1].content.find((b) => b.type === "text") as
+      | { text: string }
+      | undefined;
+    expect(downgraded).toBeDefined();
+    expect(downgraded!.text).toContain("srvtoolu_err");
+    expect(downgraded!.text).toContain("results unavailable");
   });
 
   test("repairs both orphan directions within the same assistant message", () => {

package/src/__tests__/host-app-control-proxy.test.ts

@@ -27,10 +27,8 @@ interface RegisteredInteraction {
 const registeredInteractions: RegisteredInteraction[] = [];
 
 mock.module("../runtime/pending-interactions.js", () => ({
-  register: (
-    _requestId: string,
-    entry: RegisteredInteraction,
-  ) => registeredInteractions.push(entry),
+  register: (_requestId: string, entry: RegisteredInteraction) =>
+    registeredInteractions.push(entry),
   resolve: (requestId: string) => {
     resolvedInteractionIds.push(requestId);
     return undefined;
@@ -594,6 +592,264 @@ describe("HostAppControlProxy", () => {
     });
   });
 
+  // -------------------------------------------------------------------------
+  // (c.1) Failed re-start restores the prior session
+  // -------------------------------------------------------------------------
+
+  describe("failed re-start restores prior session", () => {
+    test("non-running re-start in the same conversation restores the prior session", async () => {
+      const proxy = new HostAppControlProxy("conv-1");
+      const ctrl = new AbortController();
+
+      // Establish an active session targeting the editor.
+      const p1 = proxy.request(
+        "app_control_start",
+        { tool: "start", app: "com.example.editor" },
+        "conv-1",
+        ctrl.signal,
+      );
+      proxy.resolve(
+        (sentMessages[0] as Record<string, unknown>).requestId as string,
+        payload({ pngBase64: PNG_A }),
+      );
+      await p1;
+      expect(_getActiveAppControlSession()?.app).toBe("com.example.editor");
+
+      // Re-start against a different app — host returns "missing".
+      sentMessages.length = 0;
+      const p2 = proxy.request(
+        "app_control_start",
+        { tool: "start", app: "com.example.other" },
+        "conv-1",
+        ctrl.signal,
+      );
+      proxy.resolve(
+        (sentMessages[0] as Record<string, unknown>).requestId as string,
+        payload({ state: "missing" }),
+      );
+      await p2;
+
+      // Prior session restored (editor) — not stranded as undefined and not
+      // overwritten with the failed re-start target.
+      const session = _getActiveAppControlSession();
+      expect(session?.conversationId).toBe("conv-1");
+      expect(session?.app).toBe("com.example.editor");
+
+      proxy.dispose();
+    });
+
+    test("dispatch failure on re-start in the same conversation restores the prior session", async () => {
+      const proxy = new HostAppControlProxy("conv-1");
+      const ctrl = new AbortController();
+
+      const p1 = proxy.request(
+        "app_control_start",
+        { tool: "start", app: "com.example.editor" },
+        "conv-1",
+        ctrl.signal,
+      );
+      proxy.resolve(
+        (sentMessages[0] as Record<string, unknown>).requestId as string,
+        payload({ pngBase64: PNG_A }),
+      );
+      await p1;
+      expect(_getActiveAppControlSession()?.app).toBe("com.example.editor");
+
+      // Re-start against a different app, then abort before the host
+      // responds. The catch path in `request()` should restore the prior
+      // session rather than stranding the lock.
+      sentMessages.length = 0;
+      const reCtrl = new AbortController();
+      const p2 = proxy.request(
+        "app_control_start",
+        { tool: "start", app: "com.example.other" },
+        "conv-1",
+        reCtrl.signal,
+      );
+      reCtrl.abort();
+      const r = await p2;
+      expect(r.isError).toBe(true);
+      expect(r.content).toContain("Aborted");
+
+      const session = _getActiveAppControlSession();
+      expect(session?.conversationId).toBe("conv-1");
+      expect(session?.app).toBe("com.example.editor");
+
+      proxy.dispose();
+    });
+
+    test("late-failing start does not clobber a newer successful start (out-of-order rollback)", async () => {
+      // Overlapping starts from the same conversation where the older one
+      // fails AFTER the newer succeeds. Identity-keyed rollback must make
+      // the stale failure a no-op rather than restoring the pre-A session.
+      const proxy = new HostAppControlProxy("conv-1");
+      const ctrl = new AbortController();
+
+      // Establish prior session A.
+      const pA = proxy.request(
+        "app_control_start",
+        { tool: "start", app: "com.example.a" },
+        "conv-1",
+        ctrl.signal,
+      );
+      const reqIdA = (sentMessages[0] as Record<string, unknown>)
+        .requestId as string;
+      proxy.resolve(reqIdA, payload({ pngBase64: PNG_A }));
+      await pA;
+      expect(_getActiveAppControlSession()?.app).toBe("com.example.a");
+
+      // Start B is dispatched but its host response is delayed.
+      sentMessages.length = 0;
+      const pB = proxy.request(
+        "app_control_start",
+        { tool: "start", app: "com.example.b" },
+        "conv-1",
+        ctrl.signal,
+      );
+      const reqIdB = (sentMessages[0] as Record<string, unknown>)
+        .requestId as string;
+
+      // Start C overtakes B and succeeds first.
+      sentMessages.length = 0;
+      const pC = proxy.request(
+        "app_control_start",
+        { tool: "start", app: "com.example.c" },
+        "conv-1",
+        ctrl.signal,
+      );
+      const reqIdC = (sentMessages[0] as Record<string, unknown>)
+        .requestId as string;
+      proxy.resolve(reqIdC, payload({ pngBase64: PNG_A }));
+      await pC;
+      expect(_getActiveAppControlSession()?.app).toBe("com.example.c");
+
+      // Now B finally fails — rollback must NOT restore A or clobber C.
+      proxy.resolve(reqIdB, payload({ state: "missing" }));
+      await pB;
+
+      const session = _getActiveAppControlSession();
+      expect(session?.conversationId).toBe("conv-1");
+      expect(session?.app).toBe("com.example.c");
+
+      proxy.dispose();
+    });
+
+    test("both-fail overlapping starts release the lock (no phantom session)", async () => {
+      // Two same-conversation starts overlap, both fail. The later
+      // rollback must release the lock instead of resurrecting the
+      // earlier (never-confirmed) optimistic write.
+      const proxy = new HostAppControlProxy("conv-1");
+      const ctrl = new AbortController();
+
+      const pA = proxy.request(
+        "app_control_start",
+        { tool: "start", app: "com.example.a" },
+        "conv-1",
+        ctrl.signal,
+      );
+      const reqIdA = (sentMessages[0] as Record<string, unknown>)
+        .requestId as string;
+
+      sentMessages.length = 0;
+      const pC = proxy.request(
+        "app_control_start",
+        { tool: "start", app: "com.example.c" },
+        "conv-1",
+        ctrl.signal,
+      );
+      const reqIdC = (sentMessages[0] as Record<string, unknown>)
+        .requestId as string;
+      expect(_getActiveAppControlSession()?.app).toBe("com.example.c");
+
+      // A fails first — identity check makes it a no-op (C is live).
+      proxy.resolve(reqIdA, payload({ state: "missing" }));
+      await pA;
+      expect(_getActiveAppControlSession()?.app).toBe("com.example.c");
+
+      // C fails second — must roll back to confirmed (undefined), not
+      // to A's never-confirmed optimistic write.
+      proxy.resolve(reqIdC, payload({ state: "missing" }));
+      await pC;
+
+      expect(_getActiveAppControlSession()).toBeUndefined();
+
+      proxy.dispose();
+    });
+
+    test("late running confirmation from older overlapping start is preserved", async () => {
+      // Same-conversation overlapping starts where the older one's `running`
+      // response arrives AFTER a newer optimistic start has superseded it,
+      // and the newer one then fails. The host has actually confirmed A as
+      // running, so the lock must remain held for A rather than going
+      // undefined and desyncing from the host.
+      const proxy = new HostAppControlProxy("conv-1");
+      const ctrl = new AbortController();
+
+      // A is dispatched; do not resolve yet.
+      const pA = proxy.request(
+        "app_control_start",
+        { tool: "start", app: "com.example.a" },
+        "conv-1",
+        ctrl.signal,
+      );
+      const reqIdA = (sentMessages[0] as Record<string, unknown>)
+        .requestId as string;
+
+      // C is dispatched, overwriting the optimistic active pointer to C.
+      sentMessages.length = 0;
+      const pC = proxy.request(
+        "app_control_start",
+        { tool: "start", app: "com.example.c" },
+        "conv-1",
+        ctrl.signal,
+      );
+      const reqIdC = (sentMessages[0] as Record<string, unknown>)
+        .requestId as string;
+      expect(_getActiveAppControlSession()?.app).toBe("com.example.c");
+
+      // A finally returns running — by object identity active is no longer A,
+      // but the host has confirmed A so we must still record it as confirmed.
+      proxy.resolve(reqIdA, payload({ pngBase64: PNG_A }));
+      await pA;
+      // Active is still the newer optimistic C; nothing has rolled it back.
+      expect(_getActiveAppControlSession()?.app).toBe("com.example.c");
+
+      // C fails — rollback must restore active to A (the current confirmed),
+      // not to undefined (the snapshot prior at C's dispatch time).
+      proxy.resolve(reqIdC, payload({ state: "missing" }));
+      await pC;
+
+      const session = _getActiveAppControlSession();
+      expect(session?.conversationId).toBe("conv-1");
+      expect(session?.app).toBe("com.example.a");
+
+      proxy.dispose();
+    });
+
+    test("first-start failure releases the lock (no prior session to restore)", async () => {
+      const proxy = new HostAppControlProxy("conv-1");
+      const ctrl = new AbortController();
+
+      // No prior session; re-start the first time and get a non-running.
+      const p1 = proxy.request(
+        "app_control_start",
+        { tool: "start", app: "com.example.editor" },
+        "conv-1",
+        ctrl.signal,
+      );
+      proxy.resolve(
+        (sentMessages[0] as Record<string, unknown>).requestId as string,
+        payload({ state: "missing" }),
+      );
+      await p1;
+
+      // Lock released so another conversation can acquire.
+      expect(_getActiveAppControlSession()).toBeUndefined();
+
+      proxy.dispose();
+    });
+  });
+
   // -------------------------------------------------------------------------
   // (d) dispose releases the lock
   // -------------------------------------------------------------------------
@@ -805,8 +1061,8 @@ describe("HostAppControlProxy", () => {
         { tool: "observe", app: "com.example.app" },
         "conv-1",
         ctrl.signal,
-        "actor-principal-1",    // sourceActorPrincipalId
-        "client-A",             // targetClientId
+        "actor-principal-1", // sourceActorPrincipalId
+        "client-A", // targetClientId
       );
 
       expect(sentMessages).toHaveLength(1);
@@ -840,8 +1096,8 @@ describe("HostAppControlProxy", () => {
         { tool: "observe", app: "com.example.app" },
         "conv-1",
         ctrl.signal,
-        "user-1",    // sourceActorPrincipalId
-        "client-A",  // targetClientId → hub resolves actorPrincipalId = "user-1"
+        "user-1", // sourceActorPrincipalId
+        "client-A", // targetClientId → hub resolves actorPrincipalId = "user-1"
       );
 
       const sent = sentMessages[0] as Record<string, unknown>;
@@ -863,8 +1119,8 @@ describe("HostAppControlProxy", () => {
         { tool: "start", app: "com.example.app" },
         "conv-1",
         ctrl.signal,
-        "user-1",    // sourceActorPrincipalId
-        undefined,   // no targetClientId
+        "user-1", // sourceActorPrincipalId
+        undefined, // no targetClientId
       );
 
       const sent = sentMessages[0] as Record<string, unknown>;

package/src/__tests__/image-credentials.test.ts

@@ -12,7 +12,7 @@ mock.module("../security/secure-keys.js", () => ({
   getProviderKeyAsync: async (_provider: string) => mockProviderKey,
 }));
 
-mock.module("../providers/managed-proxy/context.js", () => ({
+mock.module("../providers/platform-proxy/context.js", () => ({
   resolveManagedProxyContext: async () => ({
     enabled: !!mockPlatformBaseUrl && !!mockAssistantApiKey,
     platformBaseUrl: mockPlatformBaseUrl,