@vellumai/assistant 0.8.1 → 0.8.3

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,18 +88,20 @@ 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);
     expect(names).toEqual([
       "disk-pressure-warning",
       "workspace-context",
+      "background-turn",
       "unified-turn-context",
       "pkb-context",
       "pkb-reminder",
       "memory-v2-static",
       "now-md",
+      "active-documents",
       "subagent-status",
       "slack-messages",
       "thread-focus",
@@ -119,6 +118,9 @@ describe("injector chain", () => {
     expect(byName.get("workspace-context")).toBe(
       DEFAULT_INJECTOR_ORDER.workspaceContext,
     );
+    expect(byName.get("background-turn")).toBe(
+      DEFAULT_INJECTOR_ORDER.backgroundTurn,
+    );
     expect(byName.get("unified-turn-context")).toBe(
       DEFAULT_INJECTOR_ORDER.unifiedTurnContext,
     );
@@ -128,6 +130,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,
     );
@@ -153,12 +158,14 @@ describe("injector chain", () => {
     expect(names).toEqual([
       "disk-pressure-warning", // 5
       "workspace-context", // 10
+      "background-turn", // 15
       "unified-turn-context", // 20
       "plugin-25", // 25 — slots in
       "pkb-context", // 30
       "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) {

package/src/__tests__/lifecycle-memory-v2-seed.test.ts

@@ -23,6 +23,7 @@ import type { AssistantConfig } from "../config/schema.js";
 
 interface TestState {
   seedCallCount: number;
+  seedCallOpts: Array<{ throwOnError?: boolean } | undefined>;
   seedShouldReject: Error | null;
   warnCalls: Array<{ obj: unknown; msg: unknown }>;
   infoCalls: Array<{ obj: unknown; msg: unknown }>;
@@ -34,10 +35,14 @@ interface TestState {
   listPagesResult: string[];
   enqueueCalls: Array<{ type: string; payload: Record<string, unknown> }>;
   clearSentinelCallCount: number;
+  // BM25 corpus-stats rebuild + reseed mocks.
+  corpusStatsBuildCount: number;
+  corpusStatsThrows: Error | null;
 }
 
 const state: TestState = {
   seedCallCount: 0,
+  seedCallOpts: [],
   seedShouldReject: null,
   warnCalls: [],
   infoCalls: [],
@@ -48,6 +53,8 @@ const state: TestState = {
   listPagesResult: [],
   enqueueCalls: [],
   clearSentinelCallCount: 0,
+  corpusStatsBuildCount: 0,
+  corpusStatsThrows: null,
 };
 
 // ---------------------------------------------------------------------------
@@ -55,12 +62,22 @@ const state: TestState = {
 // ---------------------------------------------------------------------------
 
 mock.module("../memory/v2/skill-store.js", () => ({
-  seedV2SkillEntries: async (): Promise<void> => {
+  seedV2SkillEntries: async (opts?: {
+    throwOnError?: boolean;
+  }): Promise<void> => {
     state.seedCallCount += 1;
+    state.seedCallOpts.push(opts);
     if (state.seedShouldReject) throw state.seedShouldReject;
   },
 }));
 
+// Mock the sibling CLI-command seeder so `rebuildBm25CorpusStatsAndReseedSkills`
+// (which runs both reseeds in parallel) does not invoke the real Qdrant-backed
+// implementation and emit warnings that break the no-warnings assertions below.
+mock.module("../memory/v2/cli-command-store.js", () => ({
+  seedV2CliCommandEntries: async (): Promise<void> => {},
+}));
+
 mock.module("../memory/v2/qdrant.js", () => ({
   ensureConceptPageCollection: async (): Promise<{ migrated: boolean }> => {
     state.ensureCollectionCallCount += 1;
@@ -81,6 +98,13 @@ mock.module("../memory/v2/page-store.js", () => ({
     state.listPagesResult.length > 0,
 }));
 
+mock.module("../memory/v2/sparse-bm25.js", () => ({
+  rebuildConceptPageCorpusStats: async (): Promise<void> => {
+    state.corpusStatsBuildCount += 1;
+    if (state.corpusStatsThrows) throw state.corpusStatsThrows;
+  },
+}));
+
 mock.module("../memory/jobs-store.js", () => ({
   enqueueMemoryJob: (
     type: string,
@@ -113,8 +137,11 @@ mock.module("../util/logger.js", () => ({
   }),
 }));
 
-const { maybeSeedMemoryV2Skills, maybeRebuildMemoryV2Concepts } =
-  await import("../daemon/memory-v2-startup.js");
+const {
+  maybeSeedMemoryV2Skills,
+  maybeRebuildMemoryV2Concepts,
+  rebuildBm25CorpusStatsAndReseedSkills,
+} = await import("../daemon/memory-v2-startup.js");
 
 // ---------------------------------------------------------------------------
 // Test fixtures
@@ -149,6 +176,7 @@ async function flushMicrotasks(): Promise<void> {
 
 function resetState(): void {
   state.seedCallCount = 0;
+  state.seedCallOpts = [];
   state.seedShouldReject = null;
   state.warnCalls = [];
   state.infoCalls = [];
@@ -159,6 +187,8 @@ function resetState(): void {
   state.listPagesResult = [];
   state.enqueueCalls = [];
   state.clearSentinelCallCount = 0;
+  state.corpusStatsBuildCount = 0;
+  state.corpusStatsThrows = null;
 }
 
 describe("maybeSeedMemoryV2Skills (daemon startup gate)", () => {
@@ -274,3 +304,69 @@ describe("maybeRebuildMemoryV2Concepts (daemon startup gate)", () => {
     );
   });
 });
+
+describe("rebuildBm25CorpusStatsAndReseedSkills", () => {
+  beforeEach(resetState);
+
+  test("builds corpus stats then re-seeds skills when v2 is enabled", async () => {
+    await rebuildBm25CorpusStatsAndReseedSkills(makeConfig(true));
+
+    expect(state.corpusStatsBuildCount).toBe(1);
+    expect(state.seedCallCount).toBe(1);
+    // Must pass throwOnError: true so a swallowed internal seed failure
+    // cannot trip the unconditional success log in the caller.
+    expect(state.seedCallOpts[0]).toEqual({ throwOnError: true });
+    expect(state.warnCalls).toHaveLength(0);
+  });
+
+  test("skips both corpus stats and skill reseed when v2 is disabled", async () => {
+    await rebuildBm25CorpusStatsAndReseedSkills(makeConfig(false));
+
+    expect(state.corpusStatsBuildCount).toBe(0);
+    expect(state.seedCallCount).toBe(0);
+    expect(state.warnCalls).toHaveLength(0);
+  });
+
+  test("skips the reseed and logs a warning when the corpus-stats build throws", async () => {
+    state.corpusStatsThrows = new Error("listPages failed");
+
+    // Must not throw — fire-and-forget startup must not block.
+    let thrown: unknown = null;
+    try {
+      await rebuildBm25CorpusStatsAndReseedSkills(makeConfig(true));
+    } catch (err) {
+      thrown = err;
+    }
+    expect(thrown).toBeNull();
+
+    expect(state.corpusStatsBuildCount).toBe(1);
+    expect(state.seedCallCount).toBe(0);
+    const corpusWarn = state.warnCalls.find(
+      (w) =>
+        typeof w.msg === "string" &&
+        w.msg.includes("BM25 corpus-stats rebuild failed"),
+    );
+    expect(corpusWarn).toBeTruthy();
+  });
+
+  test("swallows skill-reseed rejections after a successful corpus-stats build", async () => {
+    state.seedShouldReject = new Error("reseed failed");
+
+    let thrown: unknown = null;
+    try {
+      await rebuildBm25CorpusStatsAndReseedSkills(makeConfig(true));
+    } catch (err) {
+      thrown = err;
+    }
+    expect(thrown).toBeNull();
+
+    expect(state.corpusStatsBuildCount).toBe(1);
+    expect(state.seedCallCount).toBe(1);
+    const reseedWarn = state.warnCalls.find(
+      (w) =>
+        typeof w.msg === "string" &&
+        w.msg.includes("Failed to re-seed v2 skill entries"),
+    );
+    expect(reseedWarn).toBeTruthy();
+  });
+});

package/src/__tests__/list-messages-page-latest.test.ts

@@ -25,6 +25,10 @@ mock.module("../config/loader.js", () => ({
     provider: "test",
     memory: { enabled: false },
     rateLimit: { maxRequestsPerMinute: 0 },
+    slack: {
+      teamId: "T123",
+      teamUrl: "https://example.slack.com/",
+    },
   }),
 }));
 
@@ -32,6 +36,7 @@ import { createConversation } from "../memory/conversation-crud.js";
 import { getDb } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
 import { messages } from "../memory/schema.js";
+import { writeSlackMetadata } from "../messaging/providers/slack/message-metadata.js";
 import { handleListMessages } from "../runtime/routes/conversation-routes.js";
 import { BadRequestError } from "../runtime/routes/errors.js";
 
@@ -82,6 +87,13 @@ interface MessagePayload {
   role: string;
   content: string;
   timestamp: string;
+  slackMessage?: {
+    channelId: string;
+    channelTs: string;
+    threadTs?: string;
+    messageLink?: { appUrl?: string; webUrl?: string };
+    threadLink?: { appUrl?: string; webUrl?: string };
+  };
 }
 
 interface ListResponse {
@@ -194,6 +206,49 @@ describe("handleListMessages page=latest", () => {
     expect(body.oldestMessageId).toBeNull();
   });
 
+  test("messages expose Slack message and thread links from slackMeta", () => {
+    const conv = createConversation();
+    const db = getDb();
+    db.insert(messages)
+      .values({
+        id: "msg-slack",
+        conversationId: conv.id,
+        role: "user",
+        content: JSON.stringify([{ type: "text", text: "Slack reply" }]),
+        metadata: JSON.stringify({
+          slackMeta: writeSlackMetadata({
+            source: "slack",
+            channelId: "C123ABCDEF",
+            channelTs: "1710000000.000200",
+            threadTs: "1710000000.000100",
+            eventKind: "message",
+          }),
+        }),
+        createdAt: 1,
+      })
+      .run();
+
+    const body = callList({ conversationId: conv.id, page: "latest" });
+
+    expect(body.messages[0].slackMessage).toEqual({
+      channelId: "C123ABCDEF",
+      channelTs: "1710000000.000200",
+      threadTs: "1710000000.000100",
+      messageLink: {
+        appUrl:
+          "slack://channel?team=T123&id=C123ABCDEF&message=1710000000.000200",
+        webUrl:
+          "https://example.slack.com/archives/C123ABCDEF/p1710000000000200",
+      },
+      threadLink: {
+        appUrl:
+          "slack://channel?team=T123&id=C123ABCDEF&message=1710000000.000100",
+        webUrl:
+          "https://example.slack.com/archives/C123ABCDEF/p1710000000000100",
+      },
+    });
+  });
+
   test("page=latest on unresolved conversationKey returns null metadata contract", () => {
     const body = callList({
       conversationKey: "no-such-key",

package/src/__tests__/llm-call-pipeline.test.ts

@@ -157,7 +157,6 @@ describe("llmCall pipeline", () => {
       manifest: {
         name: "spy-llm",
         version: "0.0.1",
-        requires: { pluginRuntime: "v1" },
       },
       middleware: {
         llmCall: async (args, next, _ctx) => {
@@ -209,7 +208,6 @@ describe("llmCall pipeline", () => {
       manifest: {
         name: "spy-llm-after-default",
         version: "0.0.1",
-        requires: { pluginRuntime: "v1" },
       },
       middleware: {
         llmCall: async (args, next, _ctx) => {
@@ -255,7 +253,6 @@ describe("llmCall pipeline", () => {
       manifest: {
         name: "short-circuit-llm",
         version: "0.0.1",
-        requires: { pluginRuntime: "v1" },
       },
       middleware: { llmCall: shortCircuit },
     };