@vellumai/assistant 0.12.3-staging.1 → 0.12.3

package/src/__tests__/scripted-turn-metadata-persistence.test.ts

@@ -73,6 +73,7 @@ import type {
 import type { MessagingConversationContext } from "../daemon/conversation-messaging.js";
 import { persistQueuedMessageBody } from "../daemon/conversation-messaging.js";
 import type { MessageQueue } from "../daemon/conversation-queue-manager.js";
+import type { TrustContext } from "../daemon/trust-context-types.js";
 
 function createContext(): MessagingConversationContext {
   const channel: TurnChannelContext = {
@@ -223,3 +224,75 @@ describe("scripted-turn metadata persistence", () => {
     expect(lastUserMetadata().scripted).toBe(false);
   });
 });
+
+describe("author contact id on a persisted user message", () => {
+  const sender: TrustContext = {
+    sourceChannel: "slack",
+    trustClass: "trusted_contact",
+    requesterContactId: "contact-alice",
+  };
+
+  beforeEach(() => {
+    addMessageCalls.length = 0;
+  });
+
+  test("a message relayed from the sender names them as its author", async () => {
+    await persistQueuedMessageBody(createContext(), {
+      content: "the export endpoint needs a scoped token",
+      requestId: "req-author-typed",
+      trustContext: sender,
+      author: sender,
+    });
+
+    expect(lastUserMetadata().provenanceContactId).toBe("contact-alice");
+  });
+
+  test("a row persisted under the sender's trust but not relayed from them names no author", async () => {
+    // Machine-authored rows (ACP and subagent notifications, pointer turns)
+    // share this writer and the conversation's trust; only an explicit
+    // author names one.
+    await persistQueuedMessageBody(createContext(), {
+      content: "the delegated task finished",
+      requestId: "req-author-machine",
+      trustContext: sender,
+      metadata: { acpNotification: { acpSessionId: "acp-session-1" } },
+    });
+
+    expect(lastUserMetadata().provenanceContactId).toBeUndefined();
+  });
+
+  test.each([
+    ["scripted", { scripted: true }],
+    ["automated", { metadata: { automated: true } }],
+    ["hidden", { metadata: { hidden: true } }],
+    [
+      "ACP notification",
+      { metadata: { acpNotification: { acpSessionId: "acp-session-1" } } },
+    ],
+    [
+      "subagent notification",
+      {
+        metadata: {
+          subagentNotification: {
+            subagentId: "subagent-1",
+            label: "Research",
+            status: "completed",
+          },
+        },
+      },
+    ],
+  ] as const)(
+    "a %s row speaks in their voice without naming them",
+    async (kind, extra) => {
+      await persistQueuedMessageBody(createContext(), {
+        content: "sent on the sender's behalf",
+        requestId: `req-author-${kind}`,
+        trustContext: sender,
+        author: sender,
+        ...extra,
+      });
+
+      expect(lastUserMetadata().provenanceContactId).toBeUndefined();
+    },
+  );
+});

package/src/__tests__/secret-ingress-http.test.ts

@@ -100,6 +100,7 @@ mock.module("../runtime/guardian-reply-router.js", () => ({
 import type { AuthContext } from "../runtime/auth/types.js";
 import { handleSendMessage } from "../runtime/routes/conversation-routes.js";
 import { callHandler } from "./helpers/call-route-handler.js";
+import { mockUnownedModeSessions } from "./helpers/mock-conversation.js";
 
 const testAuthContext: AuthContext = {
   subject: "actor:self:test-user",
@@ -176,6 +177,7 @@ function makeSendMessageDeps() {
     setHostCuProxy: () => {},
     setHostAppControlProxy: () => {},
     addPreactivatedSkillId: () => {},
+    modeSessions: mockUnownedModeSessions(),
   } as unknown as import("../daemon/conversation.js").Conversation;
 
   return {

package/src/__tests__/secure-keys.test.ts

@@ -1,5 +1,6 @@
 import { randomBytes } from "node:crypto";
-import { existsSync, mkdirSync, rmSync } from "node:fs";
+import { existsSync, mkdirSync, mkdtempSync, rmSync } from "node:fs";
+import { createServer, type Server } from "node:net";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import {
@@ -11,6 +12,8 @@ import {
   test,
 } from "bun:test";
 
+import { resolveIpcEndpoint } from "@vellumai/ipc-server-utils";
+
 // ---------------------------------------------------------------------------
 // Mock logger (no-op — compatible with other test files' identical mock)
 // ---------------------------------------------------------------------------
@@ -602,4 +605,43 @@ describe("secure-keys", () => {
       expect(result.unreachable).toBe(true);
     });
   });
+
+  // -----------------------------------------------------------------------
+  // Session ownership: boot claims reconnect before identity reads
+  // -----------------------------------------------------------------------
+  describe("CES session owner skips a second open", () => {
+    test("a registered reconnect owner does not handshake a live CES socket", async () => {
+      const dir = mkdtempSync(join(tmpdir(), "ces-owner-"));
+      const socketPath = resolveIpcEndpoint("ces", { workspaceDir: dir }).path;
+      const savedDir = process.env.CES_BOOTSTRAP_SOCKET_DIR;
+      process.env.CES_BOOTSTRAP_SOCKET_DIR = dir;
+
+      const connections: Array<import("node:net").Socket> = [];
+      const server: Server = createServer((socket) => {
+        connections.push(socket);
+        socket.on("error", () => {});
+      });
+      await new Promise<void>((resolve) => server.listen(socketPath, resolve));
+
+      try {
+        setCesReconnect(async () => undefined);
+        const start = Date.now();
+        await getSecureKeyAsync("openai");
+        expect(Date.now() - start).toBeLessThan(1_000);
+        expect(getActiveBackendName()).toBe("encrypted-store");
+        expect(connections.length).toBe(0);
+      } finally {
+        for (const sock of connections) {
+          sock.destroy();
+        }
+        await new Promise<void>((resolve) => server.close(() => resolve()));
+        if (savedDir !== undefined) {
+          process.env.CES_BOOTSTRAP_SOCKET_DIR = savedDir;
+        } else {
+          delete process.env.CES_BOOTSTRAP_SOCKET_DIR;
+        }
+        rmSync(dir, { recursive: true, force: true });
+      }
+    });
+  });
 });

package/src/__tests__/send-endpoint-busy.test.ts

@@ -12,6 +12,11 @@ mock.module("../config/env.js", () => ({ isHttpAuthDisabled: () => true }));
 
 import type { AssistantEvent } from "../api/index.js";
 import type { Conversation } from "../daemon/conversation.js";
+import {
+  type MessagingConversationContext,
+  persistUserMessage,
+} from "../daemon/conversation-messaging.js";
+import { ConversationModeSessionCoordinator } from "../daemon/conversation-mode-session.js";
 import {
   getConversationByKey,
   getOrCreateConversation,
@@ -91,6 +96,7 @@ import {
   bridgeState,
   gatewayGuardianRequestsStoreBridge,
 } from "./helpers/gateway-guardian-requests-store-bridge.js";
+import { mockUnownedModeSessions } from "./helpers/mock-conversation.js";
 
 mock.module(
   "../channels/gateway-guardian-requests.js",
@@ -99,7 +105,7 @@ mock.module(
 
 import type { AssistantEventEnvelope } from "../api/index.js";
 import { __resetGuardianDeliveryCacheForTest } from "../contacts/guardian-delivery-reader.js";
-import { getDb } from "../persistence/db-connection.js";
+import { getDb, getSqlite } from "../persistence/db-connection.js";
 import { initializeDb } from "../persistence/db-init.js";
 import { RuntimeHttpServer } from "../runtime/http-server.js";
 import type { ApprovalConversationGenerator } from "../runtime/http-types.js";
@@ -116,6 +122,7 @@ function makeCompletingConversation(): Conversation {
   let processing = false;
   const messages: unknown[] = [];
   return {
+    modeSessions: mockUnownedModeSessions(),
     isProcessing: () => processing,
     persistUserMessage: (options: { requestId?: string }) => {
       processing = true;
@@ -166,6 +173,7 @@ function makeHangingConversation(): Conversation {
     requestId?: string;
   }> = [];
   return {
+    modeSessions: mockUnownedModeSessions(),
     isProcessing: () => processing,
     persistUserMessage: (options: { requestId?: string }) => {
       processing = true;
@@ -244,6 +252,7 @@ function makePendingApprovalConversation(
   });
 
   const conversation = {
+    modeSessions: mockUnownedModeSessions(),
     isProcessing: () => processing,
     persistUserMessage: (options: { requestId?: string }) => ({
       id: options.requestId ?? "msg-1",
@@ -346,6 +355,159 @@ describe("POST /v1/messages — queue-if-busy and hub publishing", () => {
 
   // ── Idle conversation: immediate processing ─────────────────────────
 
+  test.each([
+    { failure: "acceptTurn", surface: false },
+    { failure: "trackPersistedRow", surface: false },
+    { failure: "acceptTurn", surface: true },
+    { failure: "trackPersistedRow", surface: true },
+  ] as const)(
+    "dispatches committed content once despite $failure failure (surface=$surface)",
+    async ({ failure, surface }) => {
+      const conversationKey = "conv-tracking-failure";
+      const { conversationId } = getOrCreateConversation(conversationKey);
+      const modeSessions = new ConversationModeSessionCoordinator(
+        conversationId,
+      );
+      const source = surface
+        ? modeSessions.activateSource({
+            sourceId: "browser-source",
+            generation: 1,
+            mode: "browser",
+            sourceStartedAt: 100,
+          })!
+        : undefined;
+      if (source) {
+        modeSessions.claimTurn("turn-origin", source, 110);
+        modeSessions.recordStructuralWait("turn-origin", {
+          kind: "surface",
+          responseId: "surface-123",
+        });
+        modeSessions.releaseTurn("turn-origin");
+      }
+
+      const persistedRows = () =>
+        getSqlite()
+          .query<
+            { id: string; content: string },
+            [string]
+          >("SELECT id, content FROM messages WHERE conversation_id = ? AND role = 'user'")
+          .all(conversationId);
+      const acceptTurn = modeSessions.acceptTurn.bind(modeSessions);
+      const trackPersistedRow =
+        modeSessions.trackPersistedRow.bind(modeSessions);
+      const committedCounts: number[] = [];
+      const trackingFailure = mock(() => {
+        committedCounts.push(persistedRows().length);
+        throw new Error("optional session tracking failed");
+      });
+      modeSessions.acceptTurn = (...args) => {
+        const owner = acceptTurn(...args);
+        if (failure === "acceptTurn") {
+          trackingFailure();
+        }
+        return owner;
+      };
+      modeSessions.trackPersistedRow = (...args) => {
+        trackPersistedRow(...args);
+        if (failure === "trackPersistedRow") {
+          trackingFailure();
+        }
+      };
+
+      let processing = false;
+      let processingOwner = 0;
+      const releases: number[] = [];
+      const ctx = Object.assign(makeCompletingConversation(), {
+        conversationId,
+        modeSessions,
+        messages: [],
+        abortController: null as AbortController | null,
+        currentRequestId: undefined as string | undefined,
+        currentTurnClientMessageId: undefined as string | undefined,
+        currentActiveSurfaceId: surface ? "surface-123" : undefined,
+        inFlightSendRequestIds: new Map<string, string>(),
+        isProcessing: () => processing,
+        acquireProcessingFenced: async () => {
+          processing = true;
+          return ++processingOwner;
+        },
+        releaseProcessing: (owner: number) => {
+          releases.push(owner);
+          processing = false;
+          return true;
+        },
+        getTurnChannelContext: () => null,
+        getTurnInterfaceContext: () => null,
+      });
+      ctx.persistUserMessage = (options) =>
+        persistUserMessage(
+          ctx as unknown as MessagingConversationContext,
+          options,
+        );
+      const runAgentLoop = mock(async (_content: string, messageId: string) => {
+        expect(ctx.isProcessing()).toBe(true);
+        expect(ctx.messages).toHaveLength(1);
+        expect(modeSessions.getTurnOwner(messageId)?.id).toBe(source?.id);
+        modeSessions.releaseTurn(messageId, {
+          status: "completed",
+          endReason: "turn_complete",
+        });
+        ctx.releaseProcessing(processingOwner);
+        ctx.currentRequestId = undefined;
+        ctx.currentTurnClientMessageId = undefined;
+        ctx.abortController = null;
+      });
+      ctx.runAgentLoop = runAgentLoop;
+      await startServer(() => ctx);
+
+      const send = () =>
+        fetch(messagesUrl(), {
+          method: "POST",
+          headers: { "Content-Type": "application/json", ...AUTH_HEADERS },
+          body: JSON.stringify({
+            conversationKey,
+            content: "Continue the task",
+            clientMessageId: "client-message-123",
+            sourceChannel: "vellum",
+            interface: "macos",
+          }),
+        });
+      const first = await send();
+      const firstBody = (await first.json()) as {
+        accepted: boolean;
+        messageId: string;
+      };
+      expect(first.status).toBe(202);
+      expect(firstBody.accepted).toBe(true);
+      expect(runAgentLoop).toHaveBeenCalledTimes(1);
+      await runAgentLoop.mock.results[0]!.value;
+      expect(trackingFailure).toHaveBeenCalledTimes(1);
+      expect(committedCounts).toEqual([1]);
+
+      const retry = await send();
+      expect(retry.status).toBe(202);
+      expect(await retry.json()).toMatchObject(firstBody);
+      expect(runAgentLoop).toHaveBeenCalledTimes(1);
+      expect(trackingFailure).toHaveBeenCalledTimes(1);
+      expect(persistedRows()).toEqual([
+        {
+          id: firstBody.messageId,
+          content: JSON.stringify([
+            { type: "text", text: "Continue the task" },
+          ]),
+        },
+      ]);
+      expect(ctx.messages).toHaveLength(1);
+      expect(ctx.isProcessing()).toBe(false);
+      expect(ctx.abortController).toBeNull();
+      expect(ctx.currentRequestId).toBeUndefined();
+      expect(ctx.currentTurnClientMessageId).toBeUndefined();
+      expect(releases).toEqual([1, 2]);
+      expect(modeSessions.getTurnOwner(firstBody.messageId)).toBeUndefined();
+      expect(modeSessions.hasResidentWork()).toBe(false);
+    },
+  );
+
   test("returns 202 with accepted: true and messageId when conversation is idle", async () => {
     await startServer(() => makeCompletingConversation());
 

package/src/__tests__/server-history-render.test.ts

@@ -1,8 +1,11 @@
 import { beforeEach, describe, expect, test } from "bun:test";
 
 import type { AnsweredQuestion } from "../api/events/question-answered.js";
+import type {
+  ToolActivityMetadata,
+  WebFetchMetadata,
+} from "../api/events/tool-result.js";
 import { renderHistoryContent } from "../daemon/handlers/shared.js";
-import type { ToolActivityMetadata } from "../daemon/message-types/web-activity.js";
 import {
   getAttachmentsForMessage,
   linkAttachmentToMessage,
@@ -675,6 +678,93 @@ describe("renderHistoryContent", () => {
     expect(output.toolCalls[0].activityMetadata).toBeUndefined();
   });
 
+  test("hydrates persisted recall and remember activity", () => {
+    const recall: ToolActivityMetadata = {
+      recall: {
+        query: "launch plan",
+        depth: "standard",
+        sources: ["memory", "workspace"],
+        answer: "The launch moved to Friday.",
+        evidence: [
+          {
+            source: "workspace",
+            title: "notes/launch.md",
+            locator: "notes/launch.md:4",
+            excerpt: "Launch moves to Friday.",
+          },
+        ],
+        searchedSources: [
+          { source: "memory", status: "searched", evidenceCount: 0 },
+          {
+            source: "workspace",
+            status: "degraded",
+            evidenceCount: 1,
+            error: "index stale",
+          },
+        ],
+      },
+    };
+    const remember: ToolActivityMetadata = {
+      remember: { facts: ["Prefers window seats"] },
+    };
+
+    const output = renderHistoryContent([
+      {
+        type: "tool_use",
+        id: "tu_1",
+        name: "recall",
+        input: { query: "launch plan" },
+        _activityMetadata: recall,
+      },
+      {
+        type: "tool_use",
+        id: "tu_2",
+        name: "remember",
+        input: { content: "Prefers window seats" },
+        _activityMetadata: remember,
+      },
+    ]);
+
+    expect(output.toolCalls[0].activityMetadata).toEqual(recall);
+    expect(output.toolCalls[1].activityMetadata).toEqual(remember);
+  });
+
+  test("drops a malformed activity entry and keeps a valid sibling", () => {
+    const webFetch: WebFetchMetadata = {
+      url: "https://example.com",
+      finalUrl: "https://example.com",
+      status: 200,
+      byteCount: 1024,
+      charCount: 900,
+      truncated: false,
+      domain: "example.com",
+      redirectCount: 0,
+      durationMs: 40,
+    };
+    const output = renderHistoryContent([
+      {
+        type: "tool_use",
+        id: "tu_1",
+        name: "web_fetch",
+        input: { url: "https://example.com" },
+        _activityMetadata: {
+          webSearch: { query: "x", results: "not a list" },
+          webFetch,
+        },
+      },
+      {
+        type: "server_tool_use",
+        id: "tu_2",
+        name: "web_search",
+        input: { query: "x" },
+        _activityMetadata: { webSearch: { query: 42 } },
+      },
+    ]);
+
+    expect(output.toolCalls[0].activityMetadata).toEqual({ webFetch });
+    expect(output.toolCalls[1].activityMetadata).toBeUndefined();
+  });
+
   test("ignores non-array _risk*Options annotations", () => {
     // Defensive: a malformed persisted block should not throw or coerce.
     const output = renderHistoryContent([

package/src/__tests__/settings-routes.test.ts

@@ -10,7 +10,7 @@
 
 import { existsSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
-import { beforeEach, describe, expect, mock, test } from "bun:test";
+import { beforeEach, describe, expect, mock, spyOn, test } from "bun:test";
 
 // Guardian identity resolves via the gateway delivery cache, not the local
 // contacts DB. Seed it per-test via seedGatewayGuardian; persona resolution
@@ -42,17 +42,66 @@ function seedGatewayGuardian(g: {
   gatewayGuardians.push({ status: "active", ...g });
 }
 
+import {
+  getBundledSkillsDir,
+  type SkillToolManifest,
+} from "../config/skills.js";
+import * as permissions from "../permissions/checker.js";
+import { RiskLevel } from "../permissions/types.js";
 import { getSqlite } from "../persistence/db-connection.js";
 import { initializeDb } from "../persistence/db-init.js";
 import { BadRequestError, NotFoundError } from "../runtime/routes/errors.js";
 import { ROUTES } from "../runtime/routes/settings-routes.js";
 import type { RouteHandlerArgs } from "../runtime/routes/types.js";
+import { registerSkillTools, unregisterSkillTools } from "../tools/registry.js";
+import { createSkillToolsFromManifest } from "../tools/skills/skill-tool-factory.js";
 import { createGuardianBinding } from "./helpers/create-guardian-binding.js";
 
 await initializeDb();
 
 const testWorkspaceDir = process.env.VELLUM_WORKSPACE_DIR!;
 
+test("permission simulation resolves the bundled computer-use target from input", async () => {
+  const classify = spyOn(permissions, "classifyRisk").mockResolvedValue({
+    level: RiskLevel.Low,
+    reason: "Test classification",
+    matchType: "registry",
+    scopeOptions: [],
+  });
+  const check = spyOn(permissions, "check").mockResolvedValue({
+    decision: "allow",
+    reason: "Test decision",
+  });
+  const skillDir = join(getBundledSkillsDir(), "computer-use");
+  const manifest = JSON.parse(
+    readFileSync(join(skillDir, "TOOLS.json"), "utf8"),
+  ) as SkillToolManifest;
+  const skillId = "simulation-computer-use";
+  registerSkillTools(
+    skillId,
+    createSkillToolsFromManifest(manifest.tools, skillDir, "", true),
+  );
+  try {
+    for (const target of ["assistant-desktop", "connected-computer"]) {
+      const result = await getHandler(
+        "tools/simulate-permission",
+        "POST",
+      )(makeArgs({}, { toolName: "computer_use_observe", input: { target } }));
+      expect(result).toMatchObject({
+        success: true,
+        executionTarget: target === "assistant-desktop" ? "sandbox" : "host",
+      });
+      expect(check.mock.calls.at(-1)?.[3]?.executionTarget).toBe(
+        target === "assistant-desktop" ? "sandbox" : "host",
+      );
+    }
+  } finally {
+    unregisterSkillTools(skillId);
+    classify.mockRestore();
+    check.mockRestore();
+  }
+});
+
 function resetContactTables(): void {
   const sqlite = getSqlite();
   sqlite.run("DELETE FROM contact_channels");

package/src/__tests__/skill-script-runner-sandbox.test.ts

@@ -67,6 +67,19 @@ beforeAll(async () => {
     `export async function run() {
   await new Promise(resolve => setTimeout(resolve, 120_000));
   return { content: 'should not reach', isError: false };
+}`,
+    "utf-8",
+  );
+
+  await writeFile(
+    join(tempDir, "plugin-name-echo.ts"),
+    `export async function run() {
+  return {
+    content: JSON.stringify({
+      pluginName: process.env.VELLUM_PLUGIN_NAME ?? null,
+    }),
+    isError: false,
+  };
 }`,
     "utf-8",
   );
@@ -113,6 +126,25 @@ describe("runSkillToolScript sandbox — success", () => {
     expect(parsed.workingDir).toBe("/my/project");
     expect(parsed.conversationId).toBe("sess-42");
   }, 15_000);
+
+  test("sets VELLUM_PLUGIN_NAME for a plugin-owned skill tool", async () => {
+    const result = await runSkillToolScript(
+      tempDir,
+      "plugin-name-echo.ts",
+      {},
+      makeContext(),
+      {
+        target: "sandbox",
+        pluginOwner: "psk-demo",
+      },
+    );
+
+    expect(result.isError).toBe(false);
+    const parsed = JSON.parse(result.content) as {
+      pluginName: string | null;
+    };
+    expect(parsed.pluginName).toBe("psk-demo");
+  }, 15_000);
 });
 
 // ---------------------------------------------------------------------------

package/src/__tests__/subagent-fork-notifications.test.ts

@@ -22,8 +22,7 @@ mock.module("../daemon/conversation-registry.js", () => ({
       });
       return { queued: true };
     },
-    persistUserMessage: async () => ({ id: "mock-msg", deduplicated: false }),
-    runAgentLoop: async () => {},
+    kickDrainQueue: async () => {},
   }),
 }));
 

package/src/__tests__/subagent-manager-notify.test.ts

@@ -27,8 +27,7 @@ mock.module("../daemon/conversation-registry.js", () => ({
       });
       return { queued: true };
     },
-    persistUserMessage: async () => ({ id: "mock-msg", deduplicated: false }),
-    runAgentLoop: async () => {},
+    kickDrainQueue: async () => {},
   }),
 }));