@vellumai/assistant 0.10.0 → 0.10.1-staging.1

package/src/__tests__/persona-resolver.test.ts

@@ -40,6 +40,7 @@ let mockAnyGuardian: {
   contact: { userFile: string | null };
   channels: Record<string, unknown>[];
 } | null = null;
+let mockContactsByAddress: Record<string, { userFile: string | null }> = {};
 
 // ── Mock modules (must precede imports from the module under test) ──
 
@@ -48,7 +49,8 @@ mock.module("../util/platform.js", () => ({
 }));
 
 mock.module("../contacts/contact-store.js", () => ({
-  findContactByAddress: () => null,
+  findContactByAddress: (channelType: string, address: string) =>
+    mockContactsByAddress[`${channelType}:${address}`] ?? null,
   findGuardianForChannel: (channelType: string) =>
     channelType === "vellum" ? mockVellumGuardian : null,
   listGuardianChannels: () => mockAnyGuardian,
@@ -83,6 +85,7 @@ beforeEach(() => {
   mockWorkspaceDir = mkdtempSync(join(testRoot, "ws-"));
   mockVellumGuardian = null;
   mockAnyGuardian = null;
+  mockContactsByAddress = {};
 });
 
 afterEach(() => {
@@ -283,4 +286,39 @@ describe("resolveUserSlug (guardian trust, no requester identity)", () => {
 
     expect(resolveUserSlug(trustContext)).toBeNull();
   });
+
+  test("guardian identity from the verdict keys the guardian user-file info read", () => {
+    // The verdict-bound guardian is looked up by its address, not by the
+    // most-recently-verified channel guardian, so a different channel guardian
+    // does not shadow the verdict's binding.
+    mockVellumGuardian = {
+      contact: { userFile: "wrong-guardian.md" },
+      channel: {},
+    };
+    mockContactsByAddress["telegram:guardian-tg"] = {
+      userFile: "alice.md",
+    };
+
+    const trustContext = {
+      sourceChannel: "telegram",
+      trustClass: "guardian",
+      guardianExternalUserId: "guardian-tg",
+    } as TrustContext;
+
+    expect(resolveUserSlug(trustContext)).toBe("alice");
+  });
+
+  test("falls back to the channel guardian when the verdict carries no guardian identity", () => {
+    mockVellumGuardian = {
+      contact: { userFile: "alice.md" },
+      channel: {},
+    };
+
+    const trustContext = {
+      sourceChannel: "vellum",
+      trustClass: "guardian",
+    } as TrustContext;
+
+    expect(resolveUserSlug(trustContext)).toBe("alice");
+  });
 });

package/src/__tests__/platform-bash-auto-approve.test.ts

@@ -128,7 +128,7 @@ import { PermissionPrompter } from "../permissions/prompter.js";
 import { ToolExecutor } from "../tools/executor.js";
 import type { ToolContext as TC } from "../tools/types.js";
 
-initializeDb();
+await initializeDb();
 
 function makeContext(overrides?: Partial<TC>): TC {
   return {

package/src/__tests__/playbook-execution.test.ts

@@ -33,7 +33,7 @@ import { compilePlaybooks } from "../playbooks/playbook-compiler.js";
 import { parsePlaybookStatement } from "../playbooks/types.js";
 import type { ToolContext } from "../tools/types.js";
 
-initializeDb();
+await initializeDb();
 
 function getRawDb(): Database {
   return (getDb() as unknown as { $client: Database }).$client;

package/src/__tests__/playbook-tools.test.ts

@@ -29,7 +29,7 @@ import { getDb } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
 import type { ToolContext } from "../tools/types.js";
 
-initializeDb();
+await initializeDb();
 
 function getRawDb(): Database {
   return (getDb() as unknown as { $client: Database }).$client;

package/src/__tests__/plugin-api-model-profiles.test.ts

@@ -1,9 +1,39 @@
-import { writeFileSync } from "node:fs";
-import { afterEach, describe, expect, test } from "bun:test";
+import { beforeEach, describe, expect, mock, test } from "bun:test";
 
-import { invalidateConfigCache } from "../config/loader.js";
-import { getModelProfiles } from "../plugin-api/index.js";
-import { getWorkspaceConfigPath } from "../util/platform.js";
+interface MockProfileEntry {
+  label?: string;
+  description?: string;
+  provider?: string;
+  model?: string;
+  status?: string;
+  mix?: unknown;
+}
+
+let mockProfiles: Record<string, MockProfileEntry> = {};
+let mockActiveProfile: string | undefined;
+let mockProfileOrder: string[] | undefined;
+
+const realConfigLoader = await import("../config/loader.js");
+
+mock.module("../config/loader.js", () => ({
+  ...realConfigLoader,
+  getConfig: () => ({
+    llm: {
+      profiles: mockProfiles,
+      activeProfile: mockActiveProfile,
+      profileOrder: mockProfileOrder,
+    },
+  }),
+  getConfigReadOnly: () => ({
+    llm: {
+      profiles: mockProfiles,
+      activeProfile: mockActiveProfile,
+      profileOrder: mockProfileOrder,
+    },
+  }),
+}));
+
+const { getModelProfiles } = await import("../plugin-api/index.js");
 
 /**
  * `getModelProfiles()` — the runtime handle a plugin (e.g. a model router) calls
@@ -14,14 +44,23 @@ import { getWorkspaceConfigPath } from "../util/platform.js";
  * description → null, isActive → `llm.activeProfile`).
  */
 
-function writeFixtureConfig(config: Record<string, unknown>): void {
-  writeFileSync(getWorkspaceConfigPath(), JSON.stringify(config), "utf-8");
-  invalidateConfigCache();
+function writeFixtureConfig(config: {
+  llm?: {
+    profiles?: Record<string, MockProfileEntry>;
+    activeProfile?: string;
+    profileOrder?: string[];
+  };
+}): void {
+  mockProfiles = config.llm?.profiles ?? {};
+  mockActiveProfile = config.llm?.activeProfile;
+  mockProfileOrder = config.llm?.profileOrder;
 }
 
 describe("getModelProfiles", () => {
-  afterEach(() => {
-    invalidateConfigCache();
+  beforeEach(() => {
+    mockProfiles = {};
+    mockActiveProfile = undefined;
+    mockProfileOrder = undefined;
   });
 
   test("orders profiles by profileOrder then the remaining keys alphabetically", () => {
@@ -29,7 +68,12 @@ describe("getModelProfiles", () => {
     // ("balanced") and a key that resolves to no profile ("ghost").
     writeFixtureConfig({
       llm: {
-        profiles: { zeta: {}, alpha: {}, balanced: {}, "cost-optimized": {} },
+        profiles: {
+          zeta: { provider: "anthropic" },
+          alpha: { provider: "anthropic" },
+          balanced: { provider: "anthropic" },
+          "cost-optimized": { provider: "anthropic" },
+        },
         profileOrder: ["balanced", "cost-optimized", "balanced", "ghost"],
       },
     });
@@ -45,8 +89,8 @@ describe("getModelProfiles", () => {
     writeFixtureConfig({
       llm: {
         profiles: {
-          alpha: {},
-          beta: {},
+          alpha: { provider: "anthropic" },
+          beta: { provider: "anthropic" },
           blend: {
             mix: [
               { profile: "alpha", weight: 1 },
@@ -72,14 +116,14 @@ describe("getModelProfiles", () => {
     writeFixtureConfig({
       llm: {
         profiles: {
-          alpha: {},
+          alpha: { provider: "anthropic" },
           blend: {
             mix: [
               { profile: "alpha", weight: 1 },
               { profile: "beta", weight: 1 },
             ],
           },
-          beta: {},
+          beta: { provider: "anthropic" },
         },
         profileOrder: ["alpha", "blend", "beta"],
         activeProfile: "blend",
@@ -98,8 +142,8 @@ describe("getModelProfiles", () => {
     writeFixtureConfig({
       llm: {
         profiles: {
-          alpha: { status: "active" },
-          beta: { status: "disabled" },
+          alpha: { provider: "anthropic", status: "active" },
+          beta: { provider: "anthropic", status: "disabled" },
         },
         profileOrder: ["alpha", "beta"],
       },
@@ -117,7 +161,10 @@ describe("getModelProfiles", () => {
     // GIVEN a workspace where one profile sets a label and one does not.
     writeFixtureConfig({
       llm: {
-        profiles: { balanced: { label: "Balanced" }, terse: {} },
+        profiles: {
+          balanced: { provider: "anthropic", label: "Balanced" },
+          terse: { provider: "anthropic" },
+        },
         profileOrder: ["balanced", "terse"],
       },
     });
@@ -134,7 +181,10 @@ describe("getModelProfiles", () => {
     // GIVEN a workspace whose activeProfile is "beta".
     writeFixtureConfig({
       llm: {
-        profiles: { alpha: {}, beta: {} },
+        profiles: {
+          alpha: { provider: "anthropic" },
+          beta: { provider: "anthropic" },
+        },
         profileOrder: ["alpha", "beta"],
         activeProfile: "beta",
       },
@@ -153,8 +203,11 @@ describe("getModelProfiles", () => {
     writeFixtureConfig({
       llm: {
         profiles: {
-          documented: { description: "Cheaper models, slower" },
-          bare: {},
+          documented: {
+            provider: "anthropic",
+            description: "Cheaper models, slower",
+          },
+          bare: { provider: "anthropic" },
         },
         profileOrder: ["documented", "bare"],
       },

package/src/__tests__/plugin-bootstrap.test.ts

@@ -536,4 +536,82 @@ describe("plugin bootstrap", () => {
     // that snapshot, so its `onShutdown` must never fire.
     expect(shutdownFired).toBe(false);
   });
+
+  // ── .disabled sentinel gating ──────────────────────────────────────────
+  //
+  // A plugin is disabled when a `.disabled` file exists at
+  // <workspace>/plugins/<manifest-name>/.disabled. The bootstrap must
+  // skip the plugin entirely — no init, no tools, no routes, no shutdown
+  // hook — and remove it from the registry, mirroring the requiresFlag
+  // gate.
+
+  test(".disabled sentinel: init does not fire and plugin is unregistered", async () => {
+    let initFired = false;
+    const plugin = buildPlugin("sentinel-off", {
+      async init() {
+        initFired = true;
+      },
+    });
+    registerPlugin(plugin);
+
+    // Create the .disabled sentinel in the workspace plugins dir.
+    const sentinelDir = join(
+      TEST_WORKSPACE_DIR,
+      "plugins",
+      "sentinel-off",
+    );
+    const { mkdir, writeFile } = await import("node:fs/promises");
+    await mkdir(sentinelDir, { recursive: true });
+    await writeFile(join(sentinelDir, ".disabled"), "");
+
+    await bootstrapPlugins();
+
+    expect(initFired).toBe(false);
+    const names = getRegisteredPlugins().map((p) => p.manifest.name);
+    expect(names).not.toContain("sentinel-off");
+
+    await rm(sentinelDir, { recursive: true, force: true });
+  });
+
+  test(".disabled sentinel absent: plugin inits normally", async () => {
+    let initFired = false;
+    const plugin = buildPlugin("sentinel-ok", {
+      async init() {
+        initFired = true;
+      },
+    });
+    registerPlugin(plugin);
+
+    // No .disabled sentinel created — plugin should init normally.
+    await bootstrapPlugins();
+
+    expect(initFired).toBe(true);
+  });
+
+  test(".disabled sentinel: no shutdown hook entry for the skipped plugin", async () => {
+    let shutdownFired = false;
+    const plugin = buildPlugin("sentinel-shutdown", {
+      async init() {},
+      async onShutdown() {
+        shutdownFired = true;
+      },
+    });
+    registerPlugin(plugin);
+
+    const sentinelDir = join(
+      TEST_WORKSPACE_DIR,
+      "plugins",
+      "sentinel-shutdown",
+    );
+    const { mkdir, writeFile } = await import("node:fs/promises");
+    await mkdir(sentinelDir, { recursive: true });
+    await writeFile(join(sentinelDir, ".disabled"), "");
+
+    await bootstrapPlugins();
+    await runShutdownHooks("test-shutdown");
+
+    expect(shutdownFired).toBe(false);
+
+    await rm(sentinelDir, { recursive: true, force: true });
+  });
 });

package/src/__tests__/provider-platform-proxy-integration.test.ts

@@ -212,6 +212,7 @@ const MANAGED_FALLBACK_PROVIDERS: string[] = [
   "gemini",
   "openai",
   "fireworks",
+  "together",
 ];
 
 function enableManagedProxy() {
@@ -335,18 +336,25 @@ describe("managed proxy integration — credential precedence", () => {
       },
     );
 
-    test("managed bootstrap registers anthropic, openai, gemini, and fireworks", async () => {
+    test("managed bootstrap registers anthropic, openai, gemini, fireworks, and together", async () => {
       enableManagedProxy();
       mockProviderKeys = {};
       await initializeProviders(makeProvidersConfig("anthropic", "test-model"));
       expect(listProviders()).toEqual(
-        expect.arrayContaining(["anthropic", "openai", "gemini", "fireworks"]),
+        expect.arrayContaining([
+          "anthropic",
+          "openai",
+          "gemini",
+          "fireworks",
+          "together",
+        ]),
       );
-      expect(listProviders()).toHaveLength(4);
+      expect(listProviders()).toHaveLength(5);
       expect(getProviderRoutingSource("anthropic")).toBe("managed-proxy");
       expect(getProviderRoutingSource("openai")).toBe("managed-proxy");
       expect(getProviderRoutingSource("gemini")).toBe("managed-proxy");
       expect(getProviderRoutingSource("fireworks")).toBe("managed-proxy");
+      expect(getProviderRoutingSource("together")).toBe("managed-proxy");
       expect(getProviderRoutingSource("openrouter")).toBeUndefined();
     });
 
@@ -681,8 +689,14 @@ describe("config mode flip → provider reinit", () => {
 });
 
 describe("managed proxy integration — constants integrity", () => {
-  test("anthropic, openai, gemini, and fireworks have metadata with managed=true and a proxyPath", () => {
-    for (const provider of ["anthropic", "openai", "gemini", "fireworks"]) {
+  test("anthropic, openai, gemini, fireworks, and together have metadata with managed=true and a proxyPath", () => {
+    for (const provider of [
+      "anthropic",
+      "openai",
+      "gemini",
+      "fireworks",
+      "together",
+    ]) {
       const meta = PLATFORM_PROVIDER_META[provider];
       expect(meta).toBeDefined();
       expect(meta.managed).toBe(true);
@@ -715,6 +729,12 @@ describe("managed proxy integration — constants integrity", () => {
     );
   });
 
+  test("together routes through together proxy path", () => {
+    expect(PLATFORM_PROVIDER_META.together.proxyPath).toBe(
+      "/v1/runtime-proxy/together",
+    );
+  });
+
   test("openrouter is not managed proxy capable", () => {
     expect(PLATFORM_PROVIDER_META.openrouter.managed).toBe(false);
     expect(PLATFORM_PROVIDER_META.openrouter.proxyPath).toBeUndefined();

package/src/__tests__/provider-usage-tracking.test.ts

@@ -22,7 +22,7 @@ import { CallSiteConfiguredProvider } from "../providers/provider-send-message.j
 import type { Provider, ProviderResponse } from "../providers/types.js";
 import { UsageTrackingProvider } from "../providers/usage-tracking.js";
 
-initializeDb();
+await initializeDb();
 
 function setLlmConfig(raw: unknown): void {
   mockLlmConfig = LLMSchema.parse(raw) as Record<string, unknown>;

package/src/__tests__/prune-old-conversations-job.test.ts

@@ -19,7 +19,7 @@ import {
   toolInvocations,
 } from "../memory/schema.js";
 
-initializeDb();
+await initializeDb();
 
 const STALE_ID = "conv-prune-job-stale";
 const FRESH_ID = "conv-prune-job-fresh";

package/src/__tests__/reaction-persistence.test.ts

@@ -63,7 +63,7 @@ import {
 import { handleChannelInbound } from "./helpers/channel-test-adapter.js";
 import { createGuardianBinding } from "./helpers/create-guardian-binding.js";
 
-initializeDb();
+await initializeDb();
 
 // ---------------------------------------------------------------------------
 // Helpers