@vellumai/assistant 0.8.1 → 0.8.2

package/src/__tests__/document-tool-security.test.ts

@@ -0,0 +1,258 @@
+import { beforeEach, describe, expect, test } from "bun:test";
+
+import { getDocumentById } from "../documents/document-store.js";
+import { getSqlite, resetDb } from "../memory/db-connection.js";
+import {
+  executeDocumentDelete,
+  executeDocumentList,
+  executeDocumentRead,
+  executeDocumentUpdate,
+} from "../tools/document/document-tool.js";
+import type { ToolContext, ToolExecutionResult } from "../tools/types.js";
+
+function makeContext(overrides: Partial<ToolContext> = {}): ToolContext {
+  return {
+    workingDir: "/tmp/project",
+    conversationId: "conv-current",
+    trustClass: "trusted_contact",
+    executionChannel: "slack",
+    ...overrides,
+  };
+}
+
+function parseResult<T>(result: ToolExecutionResult): T {
+  return JSON.parse(result.content) as T;
+}
+
+function bootstrapDocumentTables(): void {
+  resetDb();
+  const raw = getSqlite();
+  raw.exec(/*sql*/ `
+    DROP TABLE IF EXISTS document_conversations;
+    DROP TABLE IF EXISTS documents;
+    DROP TABLE IF EXISTS conversations;
+
+    CREATE TABLE conversations (
+      id TEXT PRIMARY KEY,
+      created_at INTEGER NOT NULL DEFAULT (strftime('%s','now') * 1000)
+    );
+
+    CREATE TABLE documents (
+      surface_id TEXT PRIMARY KEY,
+      conversation_id TEXT NOT NULL REFERENCES conversations(id) ON DELETE CASCADE,
+      title TEXT NOT NULL,
+      content TEXT NOT NULL,
+      word_count INTEGER NOT NULL DEFAULT 0,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL
+    );
+
+    CREATE TABLE document_conversations (
+      surface_id TEXT NOT NULL,
+      conversation_id TEXT NOT NULL,
+      created_at INTEGER NOT NULL,
+      PRIMARY KEY (surface_id, conversation_id),
+      FOREIGN KEY (surface_id) REFERENCES documents(surface_id) ON DELETE CASCADE
+    );
+  `);
+}
+
+function seedDocument(params: {
+  surfaceId: string;
+  conversationId: string;
+  title: string;
+  content: string;
+  updatedAt: number;
+}): void {
+  const raw = getSqlite();
+  raw
+    .query(`INSERT OR IGNORE INTO conversations (id, created_at) VALUES (?, ?)`)
+    .run(params.conversationId, params.updatedAt);
+  raw
+    .query(
+      `INSERT INTO documents (surface_id, conversation_id, title, content, word_count, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?)`,
+    )
+    .run(
+      params.surfaceId,
+      params.conversationId,
+      params.title,
+      params.content,
+      params.content.split(/\s+/).filter(Boolean).length,
+      params.updatedAt,
+      params.updatedAt,
+    );
+  raw
+    .query(
+      `INSERT OR IGNORE INTO document_conversations (surface_id, conversation_id, created_at) VALUES (?, ?, ?)`,
+    )
+    .run(params.surfaceId, params.conversationId, params.updatedAt);
+}
+
+function seedFixtureDocuments(): void {
+  seedDocument({
+    surfaceId: "doc-current",
+    conversationId: "conv-current",
+    title: "Current Business Plan",
+    content: "current plan",
+    updatedAt: 1000,
+  });
+  seedDocument({
+    surfaceId: "doc-other",
+    conversationId: "conv-other",
+    title: "Other Business Plan",
+    content: "other plan",
+    updatedAt: 2000,
+  });
+  seedDocument({
+    surfaceId: "doc-percent",
+    conversationId: "conv-other",
+    title: "100% Plan",
+    content: "literal percent",
+    updatedAt: 3000,
+  });
+}
+
+describe("document tool security", () => {
+  beforeEach(() => {
+    bootstrapDocumentTables();
+    seedFixtureDocuments();
+  });
+
+  test("scopes title search to the current conversation for non-guardian remote actors", () => {
+    const result = executeDocumentList(
+      { query: "Business Plan" },
+      makeContext({ trustClass: "trusted_contact", executionChannel: "slack" }),
+    );
+
+    const body = parseResult<{ documents: Array<{ surface_id: string }> }>(
+      result,
+    );
+    expect(body.documents.map((doc) => doc.surface_id)).toEqual([
+      "doc-current",
+    ]);
+  });
+
+  test("does not treat SQL LIKE wildcards as title-search wildcards", () => {
+    const result = executeDocumentList(
+      { query: "%" },
+      makeContext({ trustClass: "guardian", executionChannel: "telegram" }),
+    );
+
+    const body = parseResult<{ documents: Array<{ surface_id: string }> }>(
+      result,
+    );
+    expect(body.documents.map((doc) => doc.surface_id)).toEqual([
+      "doc-percent",
+    ]);
+  });
+
+  test("allows guardian and local actors to use documents from previous conversations", () => {
+    const guardianContext = makeContext({
+      trustClass: "guardian",
+      executionChannel: "telegram",
+      sendToClient: () => {},
+    });
+    const guardianList = executeDocumentList(
+      { query: "Other Business" },
+      guardianContext,
+    );
+    const guardianBody = parseResult<{
+      documents: Array<{ surface_id: string }>;
+    }>(guardianList);
+    expect(guardianBody.documents.map((doc) => doc.surface_id)).toEqual([
+      "doc-other",
+    ]);
+
+    const localRead = executeDocumentRead(
+      { surface_id: "doc-other" },
+      makeContext({ trustClass: "unknown", executionChannel: "vellum" }),
+    );
+    const localBody = parseResult<{
+      success: boolean;
+      surface_id: string;
+      content: string;
+    }>(localRead);
+    expect(localBody).toMatchObject({
+      success: true,
+      surface_id: "doc-other",
+      content: "other plan",
+    });
+
+    const guardianUpdate = executeDocumentUpdate(
+      { surface_id: "doc-other", content: "guardian edit", mode: "replace" },
+      guardianContext,
+    );
+    expect(guardianUpdate.isError).toBe(false);
+    expect(getDocumentById("doc-other")?.content).toBe("guardian edit");
+
+    const guardianDelete = executeDocumentDelete(
+      { surface_id: "doc-other" },
+      guardianContext,
+    );
+    expect(guardianDelete.isError).toBe(false);
+    expect(getDocumentById("doc-other")).toBeNull();
+  });
+
+  test("blocks cross-conversation read, update, and delete for non-guardian remote actors", () => {
+    const remoteContext = makeContext({
+      trustClass: "trusted_contact",
+      executionChannel: "slack",
+      sendToClient: () => {},
+    });
+
+    const read = executeDocumentRead(
+      { surface_id: "doc-other" },
+      remoteContext,
+    );
+    expect(read.isError).toBe(true);
+    expect(parseResult<{ error: string }>(read).error).toBe(
+      "Document not found",
+    );
+
+    const update = executeDocumentUpdate(
+      {
+        surface_id: "doc-other",
+        content: "updated by another conversation",
+        mode: "replace",
+      },
+      remoteContext,
+    );
+    expect(update.isError).toBe(true);
+    expect(getDocumentById("doc-other")?.content).toBe("other plan");
+
+    const deleted = executeDocumentDelete(
+      { surface_id: "doc-other" },
+      remoteContext,
+    );
+    expect(deleted.isError).toBe(true);
+    expect(getDocumentById("doc-other")).not.toBeNull();
+  });
+
+  test("keeps current-conversation documents editable and deletable", () => {
+    const remoteContext = makeContext({
+      trustClass: "trusted_contact",
+      executionChannel: "slack",
+      sendToClient: () => {},
+    });
+
+    const read = executeDocumentRead(
+      { surface_id: "doc-current" },
+      remoteContext,
+    );
+    expect(read.isError).toBe(false);
+
+    const update = executeDocumentUpdate(
+      { surface_id: "doc-current", content: "revised plan", mode: "replace" },
+      remoteContext,
+    );
+    expect(update.isError).toBe(false);
+    expect(getDocumentById("doc-current")?.content).toBe("revised plan");
+
+    const deleted = executeDocumentDelete(
+      { surface_id: "doc-current" },
+      remoteContext,
+    );
+    expect(deleted.isError).toBe(false);
+    expect(getDocumentById("doc-current")).toBeNull();
+  });
+});

package/src/__tests__/dynamic-skill-workflow-prompt.test.ts

@@ -74,7 +74,6 @@ describe("Dynamic Skill Authoring Workflow moved to tool descriptions", () => {
       join(skillsDir, "test-skill", "SKILL.md"),
       '---\nname: "Test Skill"\ndescription: "For testing."\n---\n\nDo testing.\n',
     );
-    writeFileSync(join(skillsDir, "SKILLS.md"), "- test-skill\n");
     writeFileSync(join(TEST_DIR, "IDENTITY.md"), "I am Vellum.");
 
     const result = buildSystemPrompt();

package/src/__tests__/edit-propagation.test.ts

@@ -19,6 +19,7 @@ mock.module("../util/logger.js", () => ({
 }));
 
 import { addMessage } from "../memory/conversation-crud.js";
+import { getConversationByKey } from "../memory/conversation-key-store.js";
 import { getDb } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
 import { linkMessage, recordInbound } from "../memory/delivery-crud.js";
@@ -160,6 +161,38 @@ describe("Slack edit propagation", () => {
     expect(slackMeta!.editedAt!).toBeGreaterThanOrEqual(t0);
   });
 
+  test("threaded Slack edits use the threaded conversation key and preserve thread metadata", async () => {
+    const conversationExternalId = "C0123CHANNEL";
+    const threadTs = "1234.0000";
+    const seeded = await seedSlackMessage({
+      conversationExternalId,
+      channelTs: "1234.5678",
+      initialContent: "original text",
+    });
+
+    const resp = await handleEditIntercept({
+      sourceChannel: "slack",
+      conversationExternalId,
+      externalMessageId: nextEditEventId(),
+      sourceMessageId: seeded.channelTs,
+      sourceThreadId: threadTs,
+      canonicalAssistantId: "self",
+      assistantId: "self",
+      content: "new text",
+    });
+
+    expect((resp as Record<string, unknown>).accepted).toBe(true);
+    const threadedKey = `asst:self:slack:${conversationExternalId}:thread:${threadTs}`;
+    const editConversation = getConversationByKey(threadedKey);
+    expect(editConversation).not.toBeNull();
+    expect(editConversation!.conversationId).not.toBe(seeded.conversationId);
+
+    const after = readMessageRow(seeded.messageId);
+    const outer = JSON.parse(after.metadata!) as Record<string, unknown>;
+    const slackMeta = readSlackMetadata(outer.slackMeta as string);
+    expect(slackMeta?.threadTs).toBe(threadTs);
+  });
+
   test("is idempotent across successive edits", async () => {
     const seeded = await seedSlackMessage({
       conversationExternalId: "C0123CHANNEL",

package/src/__tests__/empty-response-pipeline.test.ts

@@ -192,7 +192,6 @@ describe("emptyResponse pipeline — custom middleware overrides", () => {
       manifest: {
         name: "force-accept",
         version: "1.0.0",
-        requires: { pluginRuntime: "v1" },
       },
       middleware: {
         emptyResponse: async () => ({ action: "accept" }),
@@ -219,7 +218,6 @@ describe("emptyResponse pipeline — custom middleware overrides", () => {
       manifest: {
         name: "force-error",
         version: "1.0.0",
-        requires: { pluginRuntime: "v1" },
       },
       middleware: {
         emptyResponse: async () => ({ action: "error" }),
@@ -239,7 +237,6 @@ describe("emptyResponse pipeline — custom middleware overrides", () => {
       manifest: {
         name: "rewrite-nudge",
         version: "1.0.0",
-        requires: { pluginRuntime: "v1" },
       },
       middleware: {
         emptyResponse: async (args, next, ctx) => {
@@ -287,7 +284,6 @@ describe("emptyResponse pipeline — custom middleware overrides", () => {
       manifest: {
         name: "late-user-empty-response",
         version: "0.0.1",
-        requires: { pluginRuntime: "v1", emptyResponseApi: "v1" },
       },
       middleware: { emptyResponse: userMiddleware },
     });

package/src/__tests__/external-plugin-loader.test.ts

@@ -70,8 +70,6 @@ describe("loadExternalPlugin — manifest", () => {
     );
     expect(registered).toBeDefined();
     expect(registered?.manifest.version).toBe("1.2.3");
-    // Defaults to pluginRuntime v1 when no `vellum.requires` is set.
-    expect(registered?.manifest.requires).toEqual({ pluginRuntime: "v1" });
   });
 
   test("strips npm scope from name", async () => {
@@ -97,56 +95,84 @@ describe("loadExternalPlugin — manifest", () => {
     );
     expect(registered?.manifest.version).toBe("0.0.0");
   });
+});
 
-  test("reads vellum.requires from package.json when present", async () => {
-    // Future direction (out of scope this PR): `requires` may carry
-    // `assistantVersion` alongside `pluginRuntime`. For today the registry
-    // validates against `ASSISTANT_API_VERSIONS` and only `pluginRuntime`
-    // is a known capability — so the loader's pass-through behavior is
-    // exercised with the keys the registry already accepts. The loader is
-    // opaque to the shape; additional keys propagate identically.
-    const dir = freshPluginDir("custom-requires");
+describe("loadExternalPlugin — plugin-api peerDependency", () => {
+  // Tests anchor against assistantPkg.version (read from the assistant's
+  // own package.json) so the matrix below stays correct across version
+  // bumps. Constructing a range from the live version + nudging up/down
+  // by one keeps the satisfy/un-satisfy cases honest.
+  test("loads when peerDependency range satisfies assistant version", async () => {
+    const dir = freshPluginDir("compat-ok");
     writePackageJson(dir, {
-      name: "custom-requires",
+      name: "compat-ok",
       version: "0.1.0",
-      vellum: { requires: { pluginRuntime: "v1" } },
+      peerDependencies: { "@vellumai/plugin-api": "*" },
     });
 
     await loadExternalPlugin(dir);
 
-    const registered = getRegisteredPlugins().find(
-      (p) => p.manifest.name === "custom-requires",
-    );
-    expect(registered?.manifest.requires).toEqual({ pluginRuntime: "v1" });
+    expect(registeredNames()).toContain("compat-ok");
   });
 
-  test("vellum.requires overrides the default — empty requires fails registration", async () => {
-    // Belt-and-suspenders proof that the loader reads `vellum.requires`
-    // rather than always defaulting: an empty `vellum.requires` propagates
-    // through, the registry rejects the plugin (missing pluginRuntime),
-    // and the registry stays empty.
-    const dir = freshPluginDir("empty-requires");
+  test("loads plugin whose peerDependency range excludes assistant version (logs error)", async () => {
+    // The host-compat gate is soft while the installation flow is in
+    // flux — an unsatisfied range produces a `log.error` but the
+    // plugin still loads. Once installation settles, this case should
+    // harden back into a hard reject.
+    const dir = freshPluginDir("compat-bad");
     writePackageJson(dir, {
-      name: "empty-requires",
+      name: "compat-bad",
       version: "0.1.0",
-      vellum: { requires: {} },
+      // A range that no real assistant version will satisfy.
+      peerDependencies: { "@vellumai/plugin-api": ">=999.0.0" },
     });
 
     await loadExternalPlugin(dir);
 
-    expect(registeredNames()).not.toContain("empty-requires");
+    expect(registeredNames()).toContain("compat-bad");
   });
 
-  test("does not synthesize a provides field", async () => {
-    const dir = freshPluginDir("no-provides");
-    writePackageJson(dir, { name: "no-provides", version: "0.1.0" });
+  test("loads plugin whose peerDependency range is unparseable (logs error)", async () => {
+    // Same soft-gate rationale as the excluded-range case above.
+    const dir = freshPluginDir("compat-bogus");
+    writePackageJson(dir, {
+      name: "compat-bogus",
+      version: "0.1.0",
+      peerDependencies: { "@vellumai/plugin-api": "not-a-real-range" },
+    });
 
     await loadExternalPlugin(dir);
 
-    const registered = getRegisteredPlugins().find(
-      (p) => p.manifest.name === "no-provides",
-    );
-    expect(registered?.manifest.provides).toBeUndefined();
+    expect(registeredNames()).toContain("compat-bogus");
+  });
+
+  test("loads with warning when no peerDependency on plugin-api is declared", async () => {
+    // Absent peerDep is non-fatal — the loader logs a warn and proceeds
+    // with no host-compat claim. The convention is opt-in while the
+    // plugin-api framework is experimental.
+    const dir = freshPluginDir("compat-absent");
+    writePackageJson(dir, {
+      name: "compat-absent",
+      version: "0.1.0",
+    });
+
+    await loadExternalPlugin(dir);
+
+    expect(registeredNames()).toContain("compat-absent");
+  });
+
+  test("loads with warning when peerDependencies is present but lacks plugin-api key", async () => {
+    const dir = freshPluginDir("compat-other-peer");
+    writePackageJson(dir, {
+      name: "compat-other-peer",
+      version: "0.1.0",
+      peerDependencies: { react: "^18.0.0" },
+    });
+
+    await loadExternalPlugin(dir);
+
+    expect(registeredNames()).toContain("compat-other-peer");
   });
 
   test("malformed package.json is logged and skipped (registry untouched)", async () => {
@@ -321,9 +347,8 @@ describe("loadExternalPlugin — tools", () => {
       `export default {
   name: "two_tools_alpha",
   description: "alpha",
-  category: "plugin",
   defaultRiskLevel: "low" as const,
-  getDefinition() { return { name: "two_tools_alpha", description: "alpha", input_schema: { type: "object", properties: {}, required: [] } }; },
+  input_schema: { type: "object", properties: {}, required: [] },
   async execute() { return { content: "a", isError: false }; },
 };
 `,
@@ -334,9 +359,8 @@ describe("loadExternalPlugin — tools", () => {
       `export default {
   name: "two_tools_beta",
   description: "beta",
-  category: "plugin",
   defaultRiskLevel: "low" as const,
-  getDefinition() { return { name: "two_tools_beta", description: "beta", input_schema: { type: "object", properties: {}, required: [] } }; },
+  input_schema: { type: "object", properties: {}, required: [] },
   async execute() { return { content: "b", isError: false }; },
 };
 `,

package/src/__tests__/filing-service.test.ts

@@ -303,6 +303,146 @@ describe("FilingService", () => {
       expect(processMessageCalls).toHaveLength(1);
     });
 
+    // Helpers for the compaction-retry tests: hold the filing run open by
+    // making processMessage return a manually-resolved promise, so `activeRun`
+    // stays set and runCompactionOnce() sees the contention path.
+    function holdFilingRun(): {
+      release: () => void;
+      filingCalls: () => number;
+      compactionCalls: () => number;
+      waitForFilingStarted: () => Promise<void>;
+    } {
+      let release: (() => void) | undefined;
+      let started = false;
+      let filingCalls = 0;
+      let compactionCalls = 0;
+
+      setTestProcessMessage((...args: unknown[]) => {
+        const callSite = (args[3] as { callSite?: string } | undefined)
+          ?.callSite;
+        if (callSite === "filingAgent") {
+          filingCalls += 1;
+          started = true;
+          return new Promise((resolve) => {
+            release = () => resolve({ messageId: "filing-done" });
+          });
+        }
+        if (callSite === "compactionAgent") {
+          compactionCalls += 1;
+        }
+        return Promise.resolve({ messageId: "mock" });
+      });
+
+      return {
+        release: () => release?.(),
+        filingCalls: () => filingCalls,
+        compactionCalls: () => compactionCalls,
+        waitForFilingStarted: async () => {
+          while (!started) await Promise.resolve();
+        },
+      };
+    }
+
+    test("schedules a near-term retry when filing run is in-flight", async () => {
+      const hold = holdFilingRun();
+      // 5s retry override paired with a production-realistic 24h compaction
+      // interval — the assertion proves retry << interval.
+      const retryMs = 5_000;
+      mockConfig.filing.compactionIntervalMs = 24 * 60 * 60 * 1000;
+      const service = new FilingService({
+        compactionContendedRetryMs: retryMs,
+      });
+      const filingPromise = service.runOnce();
+      await hold.waitForFilingStarted();
+
+      const beforeRetry = Date.now();
+      const ran = await service.runCompactionOnce();
+
+      expect(ran).toBe(false);
+      expect(service.nextCompactionAt).not.toBeNull();
+      const nextAt = service.nextCompactionAt!;
+      expect(nextAt - beforeRetry).toBeLessThan(
+        mockConfig.filing.compactionIntervalMs,
+      );
+      expect(nextAt - beforeRetry).toBeLessThanOrEqual(retryMs + 100);
+
+      hold.release();
+      await filingPromise;
+      await service.stop();
+    });
+
+    test("retry fires after filing run completes", async () => {
+      const hold = holdFilingRun();
+      const service = new FilingService({ compactionContendedRetryMs: 1 });
+      const filingPromise = service.runOnce();
+      await hold.waitForFilingStarted();
+
+      const skipped = await service.runCompactionOnce();
+      expect(skipped).toBe(false);
+      expect(hold.compactionCalls()).toBe(0);
+
+      hold.release();
+      await filingPromise;
+
+      const start = Date.now();
+      while (hold.compactionCalls() === 0 && Date.now() - start < 1000) {
+        await new Promise((resolve) => setTimeout(resolve, 5));
+      }
+
+      expect(hold.filingCalls()).toBe(1);
+      expect(hold.compactionCalls()).toBe(1);
+
+      await service.stop();
+    });
+
+    test("stop() clears a scheduled compaction retry", async () => {
+      const hold = holdFilingRun();
+      const service = new FilingService({ compactionContendedRetryMs: 50 });
+      const filingPromise = service.runOnce();
+      await hold.waitForFilingStarted();
+      await service.runCompactionOnce();
+      expect(service.nextCompactionAt).not.toBeNull();
+
+      hold.release();
+      await filingPromise;
+      await service.stop();
+
+      // After stop, the retry timer must be cleared and never fire.
+      expect(service.nextCompactionAt).toBeNull();
+      await new Promise((resolve) => setTimeout(resolve, 100));
+      expect(hold.compactionCalls()).toBe(0);
+    });
+
+    test("stop() prevents retry callback from re-arming a fresh timer", async () => {
+      // Race: the retry callback fires while filing is still in-flight and
+      // stop() has begun. The callback already cleared compactionRetryTimer,
+      // so clearCompactionRetry is a no-op. Without a stopped flag, the
+      // callback's runCompactionOnce() hits the activeRun branch and schedules
+      // a fresh retry, leaving a live timer after stop() resolves.
+      const hold = holdFilingRun();
+      const service = new FilingService({ compactionContendedRetryMs: 5 });
+      const filingPromise = service.runOnce();
+      await hold.waitForFilingStarted();
+      await service.runCompactionOnce();
+      expect(service.nextCompactionAt).not.toBeNull();
+
+      // Begin stop without awaiting — it would block on the held filing run.
+      // stop() flips `stopped` synchronously before the retry timer fires.
+      const stopPromise = service.stop();
+
+      // Wait past the retry delay. Without the guard, the callback would call
+      // runCompactionOnce(), observe activeRun, and re-arm a new retry.
+      await new Promise((resolve) => setTimeout(resolve, 50));
+      expect(service.nextCompactionAt).toBeNull();
+
+      hold.release();
+      await filingPromise;
+      await stopPromise;
+
+      expect(service.nextCompactionAt).toBeNull();
+      expect(hold.compactionCalls()).toBe(0);
+    });
+
     test("respects active hours", async () => {
       mockConfig.filing.activeHoursStart = 9;
       mockConfig.filing.activeHoursEnd = 17;

package/src/__tests__/get-skill-detail-audit.test.ts

@@ -150,13 +150,11 @@ mock.module("../skills/clawhub-files.js", () => ({
 
 mock.module("../skills/catalog-install.js", () => ({
   installSkillLocally: async () => {},
-  upsertSkillsIndex: () => {},
 }));
 
 mock.module("../skills/managed-store.js", () => ({
   createManagedSkill: () => ({ created: true }),
   deleteManagedSkill: () => ({ deleted: true }),
-  removeSkillsIndexEntry: () => {},
   validateManagedSkillId: () => null,
 }));
 
@@ -188,8 +186,6 @@ import { getSkill } from "../daemon/handlers/skills.js";
 // Helpers
 // ---------------------------------------------------------------------------
 
-
-
 // ---------------------------------------------------------------------------
 // Tests
 // ---------------------------------------------------------------------------