@vellumai/assistant 0.8.1 → 0.8.2

package/src/__tests__/inbound-slack-persistence.test.ts

@@ -151,6 +151,7 @@ describe("PR 11 — inbound Slack message metadata persistence", () => {
           channelTs: "1700000001.111111",
           threadTs: "1700000000.000001",
           displayName: "Alice",
+          actorExternalUserId: "U_ALICE",
         },
       },
       undefined,
@@ -164,6 +165,7 @@ describe("PR 11 — inbound Slack message metadata persistence", () => {
     expect(slackMeta!.channelTs).toBe("1700000001.111111");
     expect(slackMeta!.threadTs).toBe("1700000000.000001");
     expect(slackMeta!.displayName).toBe("Alice");
+    expect(slackMeta!.actorExternalUserId).toBe("U_ALICE");
   });
 
   test("Slack top-level message: slackMeta has no threadTs", async () => {

package/src/__tests__/inference-no-mode-boot-e2e.test.ts

@@ -35,7 +35,7 @@ mock.module("../security/secure-keys.js", () => ({
 }));
 
 // Managed proxy context — always unavailable in this test (no platform auth).
-mock.module("../providers/managed-proxy/context.js", () => ({
+mock.module("../providers/platform-proxy/context.js", () => ({
   buildManagedBaseUrl: async () => null,
   resolveManagedProxyContext: async () => {
     throw new Error("managed proxy not available in test");

package/src/__tests__/inference-profile-reaper.test.ts

@@ -1,6 +1,7 @@
 import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
 
 import { makeMockLogger } from "./helpers/mock-logger.js";
+import { waitFor } from "./helpers/wait-for.js";
 
 mock.module("../util/logger.js", () => ({
   getLogger: () => makeMockLogger(),
@@ -86,8 +87,9 @@ describe("inference-profile-session-reaper", () => {
     });
 
     tickInferenceProfileReaper();
-    // Allow microtasks (promise callbacks) to settle
-    await Promise.resolve();
+    await waitFor(() => publishedEvents.length === 2, {
+      message: "Timed out waiting for inference profile reaper event",
+    });
 
     // Expired rows should be cleared
     expect(getConversation(conv1.id)?.inferenceProfile).toBeNull();

package/src/__tests__/inference-profile-session-handler.test.ts

@@ -19,8 +19,10 @@ mock.module("../util/logger.js", () => ({
 // Stub the event hub so tests don't need a running event bus.
 // Exposed as a `mock(...)` so individual tests can assert publish calls.
 const publishMock = mock(async () => {});
+const broadcastMessageMock = mock(() => {});
 mock.module("../runtime/assistant-event-hub.js", () => ({
   assistantEventHub: { publish: publishMock },
+  broadcastMessage: broadcastMessageMock,
 }));
 
 // Stub buildAssistantEvent to be an identity pass-through for the event object
@@ -51,7 +53,10 @@ mock.module("../config/loader.js", () => ({
 // Real DB — same pattern as conversation-crud-inference-profile.test.ts
 // ---------------------------------------------------------------------------
 
-import { createConversation, getConversation } from "../memory/conversation-crud.js";
+import {
+  createConversation,
+  getConversation,
+} from "../memory/conversation-crud.js";
 import { getDb } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
 
@@ -83,6 +88,7 @@ describe("setInferenceProfileSession", () => {
     mockProfiles = { balanced: {}, "cost-optimized": {} };
     mockMaxTtl = undefined; // reset to default 43200
     publishMock.mockClear();
+    broadcastMessageMock.mockClear();
   });
 
   test("open with ttlSeconds=600 — returns UUID sessionId and expiresAt ≈ now + 600_000", async () => {
@@ -139,7 +145,9 @@ describe("setInferenceProfileSession", () => {
     expect(result.ttlSeconds).toBe(43200);
     expect(result.expiresAt).not.toBeNull();
     expect(result.expiresAt!).toBeGreaterThanOrEqual(before + 43200 * 1000);
-    expect(result.expiresAt!).toBeLessThanOrEqual(Date.now() + 43200 * 1000 + 1000);
+    expect(result.expiresAt!).toBeLessThanOrEqual(
+      Date.now() + 43200 * 1000 + 1000,
+    );
   });
 
   test("open over active session — replaced carries prior session info", async () => {
@@ -208,6 +216,7 @@ describe("setInferenceProfileSession", () => {
     const updatedAtBefore = before?.updatedAt;
 
     publishMock.mockClear();
+    broadcastMessageMock.mockClear();
     const result = await setInferenceProfileSession({
       conversationId: conv.id,
       profile: null,
@@ -221,7 +230,7 @@ describe("setInferenceProfileSession", () => {
 
     // No event was published — this is the load-bearing assertion for the
     // idempotency guard (Codex P2 on PR #29913).
-    expect(publishMock).not.toHaveBeenCalled();
+    expect(broadcastMessageMock).not.toHaveBeenCalled();
 
     // No DB write occurred — `updatedAt` is unchanged.
     const after = getConversation(conv.id);
@@ -240,6 +249,7 @@ describe("setInferenceProfileSession", () => {
     });
 
     publishMock.mockClear();
+    broadcastMessageMock.mockClear();
     const result = await setInferenceProfileSession({
       conversationId: conv.id,
       profile: null,
@@ -250,8 +260,8 @@ describe("setInferenceProfileSession", () => {
     // though the sticky profile was cleared.
     expect(result.replaced).toBeNull();
 
-    // The clear DID happen — DB row reflects it and an event was published.
-    expect(publishMock).toHaveBeenCalledTimes(1);
+    // The clear DID happen — DB row reflects it and legacy+sync events were published.
+    expect(broadcastMessageMock).toHaveBeenCalledTimes(2);
     const row = getConversation(conv.id);
     expect(row?.inferenceProfile).toBeNull();
   });
@@ -265,7 +275,9 @@ describe("setInferenceProfileSession", () => {
         profile: "nonexistent-profile",
         ttlSeconds: 300,
       }),
-    ).rejects.toThrow('Profile "nonexistent-profile" is not defined in llm.profiles');
+    ).rejects.toThrow(
+      'Profile "nonexistent-profile" is not defined in llm.profiles',
+    );
   });
 
   test("open with ttlSeconds=null — expiresAt=null, sessionId=null, profile kept", async () => {

package/src/__tests__/inference-profile-session-ipc.test.ts

@@ -15,6 +15,7 @@ mock.module("../util/logger.js", () => ({
 
 mock.module("../runtime/assistant-event-hub.js", () => ({
   assistantEventHub: { publish: async () => {} },
+  broadcastMessage: () => {},
 }));
 
 mock.module("../runtime/assistant-event.js", () => ({
@@ -43,9 +44,15 @@ import { ROUTES } from "../runtime/routes/inference-profile-session-routes.js";
 
 initializeDb();
 
-const openRoute = ROUTES.find((r) => r.operationId === "inference_profile_open")!;
-const closeRoute = ROUTES.find((r) => r.operationId === "inference_profile_close")!;
-const listRoute = ROUTES.find((r) => r.operationId === "inference_profile_list")!;
+const openRoute = ROUTES.find(
+  (r) => r.operationId === "inference_profile_open",
+)!;
+const closeRoute = ROUTES.find(
+  (r) => r.operationId === "inference_profile_close",
+)!;
+const listRoute = ROUTES.find(
+  (r) => r.operationId === "inference_profile_list",
+)!;
 
 function clearTables(): void {
   const db = getDb();
@@ -77,7 +84,9 @@ describe("inference_profile_open IPC op", () => {
       replaced: null,
     });
     expect((result as { sessionId: string }).sessionId).not.toBeNull();
-    expect((result as { expiresAt: number }).expiresAt).toBeGreaterThan(Date.now());
+    expect((result as { expiresAt: number }).expiresAt).toBeGreaterThan(
+      Date.now(),
+    );
   });
 
   test("opens a sticky session (no ttlSeconds) — sessionId=null, expiresAt=null", async () => {
@@ -145,7 +154,10 @@ describe("inference_profile_close IPC op", () => {
     const result = (await closeRoute.handler({
       body: { conversationId: conv.id },
       headers: {},
-    })) as { noop: boolean; closed: { profile: string; sessionId: string } | null };
+    })) as {
+      noop: boolean;
+      closed: { profile: string; sessionId: string } | null;
+    };
 
     expect(result.noop).toBe(false);
     expect(result.closed).not.toBeNull();

package/src/__tests__/injector-chain.test.ts

@@ -42,12 +42,10 @@ mock.module("../config/loader.js", () => ({
   },
 }));
 
-const { applyRuntimeInjections, composeInjectorChain } = await import(
-  "../daemon/conversation-runtime-assembly.js"
-);
-const { DEFAULT_INJECTOR_ORDER, defaultInjectorsPlugin } = await import(
-  "../plugins/defaults/injectors.js"
-);
+const { applyRuntimeInjections, composeInjectorChain } =
+  await import("../daemon/conversation-runtime-assembly.js");
+const { DEFAULT_INJECTOR_ORDER, defaultInjectorsPlugin } =
+  await import("../plugins/defaults/injectors.js");
 import {
   getInjectors,
   registerPlugin,
@@ -80,7 +78,6 @@ function wrapInPlugin(name: string, injectors: Injector[]): Plugin {
     manifest: {
       name,
       version: "0.0.1",
-      requires: { pluginRuntime: "v1" },
     },
     injectors,
   };
@@ -91,7 +88,7 @@ describe("injector chain", () => {
     resetPluginRegistryForTests();
   });
 
-  test("defaultInjectorsPlugin registers the ten defaults in the documented order", () => {
+  test("defaultInjectorsPlugin registers the defaults in the documented order", () => {
     registerPlugin(defaultInjectorsPlugin);
 
     const names = getInjectors().map((i) => i.name);
@@ -103,6 +100,7 @@ describe("injector chain", () => {
       "pkb-reminder",
       "memory-v2-static",
       "now-md",
+      "active-documents",
       "subagent-status",
       "slack-messages",
       "thread-focus",
@@ -128,6 +126,9 @@ describe("injector chain", () => {
       DEFAULT_INJECTOR_ORDER.memoryV2Static,
     );
     expect(byName.get("now-md")).toBe(DEFAULT_INJECTOR_ORDER.nowMd);
+    expect(byName.get("active-documents")).toBe(
+      DEFAULT_INJECTOR_ORDER.activeDocuments,
+    );
     expect(byName.get("subagent-status")).toBe(
       DEFAULT_INJECTOR_ORDER.subagentStatus,
     );
@@ -159,6 +160,7 @@ describe("injector chain", () => {
       "pkb-reminder", // 35
       "memory-v2-static", // 38
       "now-md", // 40
+      "active-documents", // 45
       "subagent-status", // 50
       "slack-messages", // 60
       "thread-focus", // 70

package/src/__tests__/install-skill-routing.test.ts

@@ -1,3 +1,5 @@
+import { mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
 // ---------------------------------------------------------------------------
@@ -16,10 +18,13 @@ const mockCatalogSkills = mock(
 const mockClawhubInstall = mock(
   async (
     _slug: string,
-    _opts?: { version?: string },
-  ): Promise<{ success: boolean; error?: string; skillName?: string }> => ({
-    success: true,
-  }),
+    _opts?: { version?: string; projectRoot?: string },
+  ): Promise<{
+    success: boolean;
+    error?: string;
+    skillId?: string;
+    skillDir?: string;
+  }> => ({ success: true }),
 );
 const mockInstallExternalSkill = mock(
   async (
@@ -38,13 +43,27 @@ const mockEnsureSkillEntry = mock(
     enabled: false,
   }),
 );
+const TEST_SKILLS_DIR = "/tmp/test-skills";
+const installedSkillIds = new Set<string>();
+const stagedSkillDirs = new Set<string>();
+let stagingCounter = 0;
 
 // ---------------------------------------------------------------------------
 // Mock modules — before importing module under test
 // ---------------------------------------------------------------------------
 
 mock.module("../config/skills.js", () => ({
-  loadSkillCatalog: mockCatalogSkills,
+  loadSkillCatalog: () => [
+    ...mockCatalogSkills(),
+    ...[...installedSkillIds].map((id) => ({
+      id,
+      displayName: id,
+      description: `Installed ${id}`,
+      source: "managed",
+      directoryPath: join(TEST_SKILLS_DIR, id),
+      skillFilePath: join(TEST_SKILLS_DIR, id, "SKILL.md"),
+    })),
+  ],
 }));
 
 mock.module("../skills/clawhub.js", () => ({
@@ -96,15 +115,30 @@ mock.module("../providers/provider-send-message.js", () => ({
   getConfiguredProvider: async () => null,
   userMessage: () => ({}),
 }));
-mock.module("../runtime/routes/workspace-utils.js", () => ({
-  isTextMimeType: () => true,
-}));
 mock.module("../skills/catalog-cache.js", () => ({
   getCatalog: mockGetCatalog,
 }));
 mock.module("../skills/catalog-install.js", () => ({
+  commitStagedSkillInstall: (skillId: string, stagedDir: string) => {
+    if (!stagedSkillDirs.has(stagedDir)) {
+      throw new Error(
+        `Installed skill "${skillId}" is missing SKILL.md at the skill root`,
+      );
+    }
+    stagedSkillDirs.delete(stagedDir);
+    installedSkillIds.add(skillId);
+  },
+  createSkillInstallStagingDir: () => {
+    const stagingDir = join(
+      TEST_SKILLS_DIR,
+      ".install-staging",
+      `project-${stagingCounter++}`,
+    );
+    mkdirSync(join(stagingDir, "skills"), { recursive: true });
+    return stagingDir;
+  },
+  installSkillDependenciesIfPresent: () => {},
   installSkillLocally: mockInstallSkillLocally,
-  upsertSkillsIndex: () => {},
 }));
 mock.module("../skills/catalog-search.js", () => ({
   filterByQuery: () => [],
@@ -112,7 +146,6 @@ 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", () => ({
@@ -121,7 +154,7 @@ mock.module("../memory/graph/capability-seed.js", () => ({
   seedUninstalledCatalogSkillMemories: async () => {},
 }));
 mock.module("../util/platform.js", () => ({
-  getWorkspaceSkillsDir: () => "/tmp/test-skills",
+  getWorkspaceSkillsDir: () => TEST_SKILLS_DIR,
 }));
 mock.module("../daemon/handlers/shared.js", () => ({
   CONFIG_RELOAD_DEBOUNCE_MS: 100,
@@ -141,13 +174,17 @@ import { installSkill } from "../daemon/handlers/skills.js";
 // Helpers
 // ---------------------------------------------------------------------------
 
-
 // ---------------------------------------------------------------------------
 // Tests
 // ---------------------------------------------------------------------------
 
 describe("installSkill routing", () => {
   beforeEach(() => {
+    rmSync(TEST_SKILLS_DIR, { recursive: true, force: true });
+    mkdirSync(TEST_SKILLS_DIR, { recursive: true });
+    installedSkillIds.clear();
+    stagedSkillDirs.clear();
+    stagingCounter = 0;
     mockCatalogSkills.mockReset();
     mockClawhubInstall.mockReset();
     mockInstallExternalSkill.mockReset();
@@ -158,7 +195,12 @@ describe("installSkill routing", () => {
 
     // Defaults
     mockCatalogSkills.mockReturnValue([]);
-    mockClawhubInstall.mockResolvedValue({ success: true });
+    mockClawhubInstall.mockImplementation(async (slug, opts) => {
+      const skillId = slug.includes("/") ? slug.split("/").pop()! : slug;
+      const projectRoot = opts?.projectRoot ?? TEST_SKILLS_DIR;
+      const skillDir = stageClawhubSkill(projectRoot, skillId);
+      return { success: true, skillId, skillDir };
+    });
     mockInstallExternalSkill.mockResolvedValue(undefined);
     mockGetCatalog.mockResolvedValue([]);
     mockInstallSkillLocally.mockResolvedValue(undefined);
@@ -166,13 +208,38 @@ describe("installSkill routing", () => {
     mockEnsureSkillEntry.mockReturnValue({ enabled: false });
   });
 
-  test("install with origin: 'skillssh' and multi-segment slug routes to installExternalSkill", async () => {
-    const result = await installSkill(
-      {
-        slug: "vercel-labs/agent-skills/react-best-practices",
-        origin: "skillssh",
-      },
+  function writeInstalledSkill(skillId: string): void {
+    const skillDir = join(TEST_SKILLS_DIR, skillId);
+    mkdirSync(skillDir, { recursive: true });
+    writeFileSync(
+      join(skillDir, "SKILL.md"),
+      `---
+name: "${skillId}"
+description: "Installed test skill."
+---
+
+Body.
+`,
+      "utf-8",
     );
+    installedSkillIds.add(skillId);
+  }
+
+  function stageClawhubSkill(projectRoot: string, skillId: string): string {
+    const skillDir = join(projectRoot, "skills", skillId);
+    stagedSkillDirs.add(skillDir);
+    return skillDir;
+  }
+
+  test("install with origin: 'skillssh' and multi-segment slug routes to installExternalSkill", async () => {
+    mockInstallExternalSkill.mockImplementation(async () => {
+      writeInstalledSkill("react-best-practices");
+    });
+
+    const result = await installSkill({
+      slug: "vercel-labs/agent-skills/react-best-practices",
+      origin: "skillssh",
+    });
 
     expect(result.success).toBe(true);
     expect(mockInstallExternalSkill).toHaveBeenCalledTimes(1);
@@ -189,11 +256,21 @@ describe("installSkill routing", () => {
   });
 
   test("install without origin falls through to clawhub for simple slugs", async () => {
+    mockClawhubInstall.mockImplementation(async (slug: string) => {
+      const skillDir = stageClawhubSkill(
+        join(TEST_SKILLS_DIR, ".install-staging", "project-0"),
+        slug,
+      );
+      return { success: true, skillId: slug, skillDir };
+    });
+
     const result = await installSkill({ slug: "some-clawhub-skill" });
 
     expect(result.success).toBe(true);
     expect(mockClawhubInstall).toHaveBeenCalledTimes(1);
     expect(mockClawhubInstall).toHaveBeenCalledWith("some-clawhub-skill", {
+      contactId: undefined,
+      projectRoot: join(TEST_SKILLS_DIR, ".install-staging", "project-0"),
       version: undefined,
     });
     // Should not have called installExternalSkill
@@ -201,19 +278,51 @@ describe("installSkill routing", () => {
   });
 
   test("install with origin: 'clawhub' routes directly to clawhub without trying skills.sh", async () => {
-    const result = await installSkill(
-      { slug: "my-skill", origin: "clawhub" },
-    );
+    mockClawhubInstall.mockImplementation(async (slug: string) => {
+      const skillDir = stageClawhubSkill(
+        join(TEST_SKILLS_DIR, ".install-staging", "project-0"),
+        slug,
+      );
+      return { success: true, skillId: slug, skillDir };
+    });
+
+    const result = await installSkill({ slug: "my-skill", origin: "clawhub" });
 
     expect(result.success).toBe(true);
     expect(mockClawhubInstall).toHaveBeenCalledTimes(1);
     expect(mockInstallExternalSkill).not.toHaveBeenCalled();
   });
 
+  test("clawhub install fails when the installed skill root is not discoverable", async () => {
+    mockClawhubInstall.mockResolvedValue({
+      success: true,
+      skillId: "missing-root-skill",
+      skillDir: join(
+        TEST_SKILLS_DIR,
+        ".install-staging",
+        "project-0",
+        "skills",
+        "missing-root-skill",
+      ),
+    });
+
+    const result = await installSkill({
+      slug: "missing-root-skill",
+      origin: "clawhub",
+    });
+
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(result.error).toContain("missing SKILL.md");
+    }
+  });
+
   test("multi-segment slug without explicit origin auto-routes to skills.sh", async () => {
-    const result = await installSkill(
-      { slug: "owner/repo/my-skill" },
-    );
+    mockInstallExternalSkill.mockImplementation(async () => {
+      writeInstalledSkill("my-skill");
+    });
+
+    const result = await installSkill({ slug: "owner/repo/my-skill" });
 
     expect(result.success).toBe(true);
     expect(mockInstallExternalSkill).toHaveBeenCalledTimes(1);
@@ -229,11 +338,21 @@ describe("installSkill routing", () => {
   });
 
   test("multi-segment slug with origin: 'clawhub' skips skills.sh and routes to clawhub", async () => {
+    mockClawhubInstall.mockImplementation(async (slug: string) => {
+      const skillId = slug.split("/").pop()!;
+      const skillDir = stageClawhubSkill(
+        join(TEST_SKILLS_DIR, ".install-staging", "project-0"),
+        skillId,
+      );
+      return { success: true, skillId, skillDir };
+    });
+
     // Even though the slug looks like skills.sh format, explicit origin: "clawhub"
     // should override the auto-detection and go to clawhub
-    const result = await installSkill(
-      { slug: "owner/repo/my-skill", origin: "clawhub" },
-    );
+    const result = await installSkill({
+      slug: "owner/repo/my-skill",
+      origin: "clawhub",
+    });
 
     expect(result.success).toBe(true);
     expect(mockClawhubInstall).toHaveBeenCalledTimes(1);
@@ -251,9 +370,10 @@ describe("installSkill routing", () => {
       },
     ]);
 
-    const result = await installSkill(
-      { slug: "bundled-skill", origin: "skillssh" },
-    );
+    const result = await installSkill({
+      slug: "bundled-skill",
+      origin: "skillssh",
+    });
 
     expect(result.success).toBe(true);
     // Should have auto-enabled via ensureSkillEntry, not called external install
@@ -266,12 +386,10 @@ describe("installSkill routing", () => {
       new Error("Skill not found in repo"),
     );
 
-    const result = await installSkill(
-      {
-        slug: "owner/repo/nonexistent-skill",
-        origin: "skillssh",
-      },
-    );
+    const result = await installSkill({
+      slug: "owner/repo/nonexistent-skill",
+      origin: "skillssh",
+    });
 
     expect(result.success).toBe(false);
     if (!result.success) {