@vellumai/assistant 0.10.4 → 0.10.5-dev.202607022329.d89bf2f

package/src/__tests__/stt-hints.test.ts

@@ -1,93 +1,6 @@
-import { beforeEach, describe, expect, mock, test } from "bun:test";
+import { describe, expect, test } from "bun:test";
 
-import type { ContactWithChannels } from "../contacts/types.js";
-
-// ---------------------------------------------------------------------------
-// Mock state for resolveCallHints tests
-// ---------------------------------------------------------------------------
-
-let mockAssistantName: string | null = "Nova";
-let mockGuardianName: string = "Alex";
-let mockTargetContact: ContactWithChannels | null = null;
-let mockRecentContacts: ContactWithChannels[] = [];
-let mockFindContactByAddressThrows = false;
-let mockListContactsThrows = false;
-
-// Guardian deliveries returned by the mocked gateway reader. resolveGuardianName
-// is mocked to echo mockGuardianName, so the displayName here is captured below.
-let mockGuardianDelivery: Array<{
-  channelType: string;
-  status: string;
-  displayName: string | null;
-}> | null = null;
-let lastGuardianDisplayNameSeen: string | null | undefined;
-
-const logWarnFn = mock(() => {});
-
-// ---------------------------------------------------------------------------
-// Mock modules — must be before importing module under test
-// ---------------------------------------------------------------------------
-
-mock.module("../daemon/identity-helpers.js", () => ({
-  getAssistantName: () => mockAssistantName,
-}));
-
-mock.module("../prompts/user-reference.js", () => ({
-  DEFAULT_USER_REFERENCE: "my human",
-  resolveGuardianName: (displayName?: string | null) => {
-    lastGuardianDisplayNameSeen = displayName;
-    return mockGuardianName;
-  },
-}));
-
-mock.module("../contacts/contact-store.js", () => ({
-  findContactByAddress: (_type: string, _address: string) => {
-    if (mockFindContactByAddressThrows) {
-      throw new Error("DB error: findContactByAddress");
-    }
-    return mockTargetContact;
-  },
-  listContacts: (_limit?: number) => {
-    if (mockListContactsThrows) {
-      throw new Error("DB error: listContacts");
-    }
-    return mockRecentContacts;
-  },
-}));
-
-mock.module("../contacts/guardian-delivery-reader.js", () => ({
-  getGuardianDelivery: async () => mockGuardianDelivery,
-  guardianForChannel: (
-    list: Array<{ channelType: string; status: string }>,
-    channelType: string,
-  ) => list.find((g) => g.channelType === channelType && g.status === "active"),
-  anyGuardian: (list: unknown[]) => list[0],
-}));
-
-// Bun's mock.module for "../util/logger.js" doesn't intercept the transitive
-// import in stt-hints.ts due to a Bun limitation. Mocking pino at the package
-// level works because getLogger uses a Proxy that lazily creates a pino child
-// logger — intercepting pino itself captures all log calls.
-const mockChildLogger = {
-  debug: () => {},
-  info: () => {},
-  warn: logWarnFn,
-  error: () => {},
-  child: () => mockChildLogger,
-};
-const mockPinoLogger = Object.assign(() => mockChildLogger, {
-  destination: () => ({}),
-  multistream: () => ({}),
-});
-mock.module("pino", () => ({ default: mockPinoLogger }));
-mock.module("pino-pretty", () => ({ default: () => ({}) }));
-
-// Import after mocking
-import {
-  buildSttHints,
-  resolveCallHints,
-  type SttHintsInput,
-} from "../calls/stt-hints.js";
+import { buildSttHints, type SttHintsInput } from "../calls/stt-hints.js";
 
 function emptyInput(): SttHintsInput {
   return {
@@ -307,170 +220,3 @@ describe("buildSttHints", () => {
     expect(buildSttHints(input)).toBe("");
   });
 });
-
-// ---------------------------------------------------------------------------
-// resolveCallHints — wiring and error resilience
-// ---------------------------------------------------------------------------
-
-function makeContact(displayName: string): ContactWithChannels {
-  const now = Date.now();
-  return {
-    id: `contact-${displayName.toLowerCase()}`,
-    displayName,
-    notes: null,
-    role: "contact",
-    lastInteraction: null,
-    interactionCount: 0,
-    createdAt: now,
-    updatedAt: now,
-    contactType: "human",
-    userFile: null,
-    channels: [],
-  };
-}
-
-describe("resolveCallHints", () => {
-  beforeEach(() => {
-    mockAssistantName = "Nova";
-    mockGuardianName = "Alex";
-    mockTargetContact = null;
-    mockRecentContacts = [];
-    mockFindContactByAddressThrows = false;
-    mockListContactsThrows = false;
-    mockGuardianDelivery = null;
-    lastGuardianDisplayNameSeen = undefined;
-    logWarnFn.mockClear();
-  });
-
-  test("guardian displayName for hints comes from the gateway binding", async () => {
-    mockGuardianDelivery = [
-      {
-        channelType: "phone",
-        status: "active",
-        displayName: "GatewayGuardian",
-      },
-    ];
-
-    await resolveCallHints(null, []);
-
-    expect(lastGuardianDisplayNameSeen).toBe("GatewayGuardian");
-  });
-
-  test("happy path wires all sources correctly", async () => {
-    mockTargetContact = makeContact("Alice");
-    mockRecentContacts = [makeContact("Bob"), makeContact("Charlie")];
-
-    const session = {
-      task: "Call Alice at Acme",
-      toNumber: "+15551234567",
-      fromNumber: "+15559876543",
-      direction: "outbound" as const,
-      inviteFriendName: "Dave",
-      inviteGuardianName: "Eve",
-    };
-
-    const result = await resolveCallHints(session, ["StaticHint"]);
-    const parts = result.split(",");
-
-    expect(parts).toContain("StaticHint");
-    expect(parts).toContain("Nova");
-    expect(parts).toContain("Alex");
-    expect(parts).toContain("Alice");
-    expect(parts).toContain("Dave");
-    expect(parts).toContain("Eve");
-    expect(parts).toContain("Bob");
-    expect(parts).toContain("Charlie");
-    // Proper nouns from task description
-    expect(parts).toContain("Acme");
-    expect(logWarnFn).not.toHaveBeenCalled();
-  });
-
-  test("findContactByAddress failure is caught and logged without throwing", async () => {
-    mockFindContactByAddressThrows = true;
-    mockRecentContacts = [makeContact("Bob")];
-
-    const session = {
-      task: null,
-      toNumber: "+15551234567",
-      fromNumber: "+15559876543",
-      direction: "outbound" as const,
-      inviteFriendName: null,
-      inviteGuardianName: null,
-    };
-
-    // Should not throw
-    const result = await resolveCallHints(session, []);
-    const parts = result.split(",");
-
-    // Target contact should be absent (lookup failed)
-    // But other sources should still work
-    expect(parts).toContain("Nova");
-    expect(parts).toContain("Alex");
-    expect(parts).toContain("Bob");
-    expect(logWarnFn).toHaveBeenCalled();
-  });
-
-  test("listContacts failure is caught and logged without throwing", async () => {
-    mockListContactsThrows = true;
-    mockTargetContact = makeContact("Alice");
-
-    const session = {
-      task: null,
-      toNumber: "+15551234567",
-      fromNumber: "+15559876543",
-      direction: "outbound" as const,
-      inviteFriendName: null,
-      inviteGuardianName: null,
-    };
-
-    // Should not throw
-    const result = await resolveCallHints(session, []);
-    const parts = result.split(",");
-
-    // Recent contacts should be absent (listing failed)
-    // But other sources should still work
-    expect(parts).toContain("Nova");
-    expect(parts).toContain("Alex");
-    expect(parts).toContain("Alice");
-    expect(logWarnFn).toHaveBeenCalled();
-  });
-
-  test("inbound call resolves caller contact from fromNumber", async () => {
-    mockTargetContact = makeContact("Alice");
-    mockRecentContacts = [makeContact("Bob")];
-
-    const session = {
-      task: null,
-      toNumber: "+15559876543",
-      fromNumber: "+15551234567",
-      direction: "inbound" as const,
-      inviteFriendName: null,
-      inviteGuardianName: null,
-    };
-
-    const result = await resolveCallHints(session, []);
-    const parts = result.split(",");
-
-    // For inbound, the contact found via fromNumber should appear as caller, not target
-    expect(parts).toContain("Alice");
-    expect(parts).toContain("Nova");
-    expect(parts).toContain("Alex");
-    expect(parts).toContain("Bob");
-    expect(logWarnFn).not.toHaveBeenCalled();
-  });
-
-  test("null session produces hints from assistant name, guardian name, and recent contacts", async () => {
-    mockRecentContacts = [makeContact("RecentOne"), makeContact("RecentTwo")];
-
-    const result = await resolveCallHints(null, ["Static"]);
-    const parts = result.split(",");
-
-    expect(parts).toContain("Static");
-    expect(parts).toContain("Nova");
-    expect(parts).toContain("Alex");
-    expect(parts).toContain("RecentOne");
-    expect(parts).toContain("RecentTwo");
-    // No target contact lookup should have been attempted (no session)
-    expect(logWarnFn).not.toHaveBeenCalled();
-  });
-});

package/src/__tests__/subagent-allowlist-validation.test.ts

@@ -0,0 +1,47 @@
+import { describe, expect, test } from "bun:test";
+
+import { SUBAGENT_ROLE_REGISTRY } from "../subagent/index.js";
+import { findUnknownAllowlistTools } from "../subagent/validate-allowlists.js";
+
+/** Union of every tool name referenced by any role allowlist. */
+function allReferencedToolNames(): Set<string> {
+  const names = new Set<string>();
+  for (const config of Object.values(SUBAGENT_ROLE_REGISTRY)) {
+    for (const tool of config.allowedTools ?? []) names.add(tool);
+  }
+  return names;
+}
+
+describe("findUnknownAllowlistTools", () => {
+  test("returns [] when every referenced tool name is registered", () => {
+    // A registered-name set that covers every allowlist entry yields no
+    // unknowns — a fully-resolvable registry is a silent no-op.
+    expect(findUnknownAllowlistTools(allReferencedToolNames())).toEqual([]);
+  });
+
+  test("flags an allowlist entry whose tool name is not registered", () => {
+    // Simulate a tool rename that left the allowlists stale: drop one real
+    // name from the registered set and confirm exactly the roles that list it
+    // are flagged — and nothing else.
+    const registered = allReferencedToolNames();
+    registered.delete("web_search");
+
+    const unknown = findUnknownAllowlistTools(registered);
+    expect(unknown.length).toBeGreaterThan(0);
+    expect(unknown.every((u) => u.tool === "web_search")).toBe(true);
+
+    const flaggedRoles = unknown.map((u) => u.role).sort();
+    const expectedRoles = Object.entries(SUBAGENT_ROLE_REGISTRY)
+      .filter(([, config]) => config.allowedTools?.includes("web_search"))
+      .map(([role]) => role)
+      .sort();
+    expect(flaggedRoles).toEqual(expectedRoles);
+  });
+
+  test("skips roles with no allowlist (general imposes no filter)", () => {
+    // `general` has allowedTools: undefined, so even against an empty registry
+    // it contributes no entries.
+    const unknown = findUnknownAllowlistTools(new Set());
+    expect(unknown.some((u) => u.role === "general")).toBe(false);
+  });
+});

package/src/__tests__/subagent-call-site-routing.test.ts

@@ -25,6 +25,7 @@ interface CapturedConversationState {
   trustContext: unknown;
   authContext: unknown;
   assistantId: string | undefined;
+  enabledPlugins: string[] | null | undefined;
 }
 
 const capturedConversations: CapturedConversationState[] = [];
@@ -46,6 +47,7 @@ class FakeConversation {
       trustContext: undefined,
       authContext: undefined,
       assistantId: undefined,
+      enabledPlugins: undefined,
     };
     capturedConversations.push(this.capturedState);
   }
@@ -63,6 +65,9 @@ class FakeConversation {
   setAssistantId(assistantId: string | null) {
     this.capturedState.assistantId = assistantId ?? undefined;
   }
+  setEnabledPlugins(plugins: string[] | null) {
+    this.capturedState.enabledPlugins = plugins;
+  }
   hasSystemPromptOverride = false;
   setSubagentAllowedTools() {}
   setPreactivatedSkillIds() {}
@@ -328,6 +333,73 @@ describe("SubagentManager — provider call-site routing", () => {
     expect(createdConversation.trustContext).not.toBe(parentTrustContext);
     expect(createdConversation.authContext).not.toBe(parentAuthContext);
   });
+
+  test("copies the parent's plugin scope into the spawned conversation (by value)", async () => {
+    setLlmConfig({
+      default: {
+        provider: "anthropic",
+        provider_connection: "anthropic-conn",
+        model: "claude-opus-4-7",
+      },
+    });
+
+    const parentScope = ["caveman", "data"];
+
+    capturedConversations.length = 0;
+    clearConversations();
+    const manager = new SubagentManager();
+    setConversation("parent-scoped", {
+      enabledPlugins: parentScope,
+      getAuthContext: () => undefined,
+      getCurrentSystemPrompt: () => "parent system",
+    } as any);
+
+    await manager.spawn(
+      {
+        parentConversationId: "parent-scoped",
+        label: "scoped",
+        objective: "use a plugin skill",
+      },
+      () => {},
+    );
+
+    const createdConversation = capturedConversations[0];
+    // The subagent inherits the parent chat's plugin scope so it can't reach
+    // plugins the user deselected in the parent.
+    expect(createdConversation?.enabledPlugins).toEqual(["caveman", "data"]);
+    // Copied by value so later parent/child edits don't alias one another.
+    expect(createdConversation?.enabledPlugins).not.toBe(parentScope);
+  });
+
+  test("propagates a null (unrestricted) parent scope unchanged", async () => {
+    setLlmConfig({
+      default: {
+        provider: "anthropic",
+        provider_connection: "anthropic-conn",
+        model: "claude-opus-4-7",
+      },
+    });
+
+    capturedConversations.length = 0;
+    clearConversations();
+    const manager = new SubagentManager();
+    setConversation("parent-unscoped", {
+      enabledPlugins: null,
+      getAuthContext: () => undefined,
+      getCurrentSystemPrompt: () => "parent system",
+    } as any);
+
+    await manager.spawn(
+      {
+        parentConversationId: "parent-unscoped",
+        label: "unscoped",
+        objective: "use anything",
+      },
+      () => {},
+    );
+
+    expect(capturedConversations[0]?.enabledPlugins).toBeNull();
+  });
 });
 
 // ── Direct unit test for CallSiteRoutingProvider's selection logic ─────────

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

@@ -177,15 +177,27 @@ describe("Fork completion notifications", () => {
       deduplicated: false,
     });
     managed.conversation!.runAgentLoop = async () => {};
+    // Leave a trailing assistant message so the completion notification inlines
+    // the fork's synthesis (the new behavior) rather than the empty-text path.
+    managed.conversation!.messages = [
+      {
+        role: "assistant",
+        content: [{ type: "text", text: "Internal analysis: revenue up 20%." }],
+      },
+    ];
 
     await asInternals(manager).runSubagent(subagentId, "Analyze data");
 
     expect(capturedNotifications).toHaveLength(1);
+    // The synthesis is inlined, and a silent fork is flagged for internal use.
     expect(capturedNotifications[0].message).toContain(
-      "do NOT share raw fork output with the user",
+      "Internal analysis: revenue up 20%.",
     );
     expect(capturedNotifications[0].message).toContain(
-      '[Fork "Analysis fork" completed]',
+      "do not relay the raw fork output to the user",
+    );
+    expect(capturedNotifications[0].message).toContain(
+      '[Fork "Analysis fork" completed — result below]',
     );
 
     asInternals(manager).stopSweep();

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

@@ -0,0 +1,122 @@
+import { beforeEach, describe, expect, test } from "bun:test";
+
+import { migrateCreateSubagentsTable } from "../persistence/migrations/311-create-subagents-table.js";
+import { resetTestTables } from "../persistence/raw-query.js";
+import {
+  deleteSubagentRecord,
+  loadAllSubagentRecords,
+  type SubagentRecord,
+  upsertSubagentRecord,
+} from "../persistence/subagent-store.js";
+import { SubagentManager } from "../subagent/manager.js";
+
+function record(over: Partial<SubagentRecord> = {}): SubagentRecord {
+  return {
+    id: "s1",
+    parentConversationId: "parent-1",
+    conversationId: "conv-1",
+    label: "research-pricing",
+    objective: "Research competitor pricing",
+    role: "researcher",
+    isFork: false,
+    sendResultToUser: true,
+    status: "running",
+    error: null,
+    createdAt: 1000,
+    startedAt: 1001,
+    completedAt: null,
+    inputTokens: 5,
+    outputTokens: 7,
+    estimatedCost: 0.01,
+    ...over,
+  };
+}
+
+beforeEach(() => {
+  // Idempotent; the table may already exist from a prior run.
+  migrateCreateSubagentsTable();
+  resetTestTables("subagents");
+});
+
+describe("subagent-store", () => {
+  test("round-trips a record, mapping booleans and nullable fields", () => {
+    upsertSubagentRecord(
+      record({ isFork: true, sendResultToUser: null, error: null }),
+    );
+
+    const rows = loadAllSubagentRecords();
+    expect(rows).toHaveLength(1);
+    expect(rows[0]).toMatchObject({
+      id: "s1",
+      isFork: true,
+      sendResultToUser: null,
+      role: "researcher",
+      status: "running",
+      inputTokens: 5,
+    });
+  });
+
+  test("upsert refreshes mutable lifecycle fields on conflict", () => {
+    upsertSubagentRecord(record({ status: "running" }));
+    upsertSubagentRecord(
+      record({ status: "completed", completedAt: 2000, outputTokens: 99 }),
+    );
+
+    const rows = loadAllSubagentRecords();
+    expect(rows).toHaveLength(1);
+    expect(rows[0].status).toBe("completed");
+    expect(rows[0].completedAt).toBe(2000);
+    expect(rows[0].outputTokens).toBe(99);
+  });
+
+  test("delete removes the record", () => {
+    upsertSubagentRecord(record());
+    deleteSubagentRecord("s1");
+    expect(loadAllSubagentRecords()).toHaveLength(0);
+  });
+});
+
+describe("SubagentManager.rehydrateFromDb", () => {
+  test("marks in-flight subagents interrupted and loads terminal ones as-is", () => {
+    upsertSubagentRecord(
+      record({ id: "running-1", label: "still-running", status: "running" }),
+    );
+    upsertSubagentRecord(
+      record({
+        id: "done-1",
+        label: "finished",
+        status: "completed",
+        completedAt: 2000,
+      }),
+    );
+
+    const mgr = new SubagentManager();
+    const { rehydrated, interrupted } = mgr.rehydrateFromDb();
+
+    expect(rehydrated).toBe(2);
+    expect(interrupted).toBe(1);
+
+    // In-flight → interrupted (not auto-resumed); terminal loads unchanged.
+    expect(mgr.getState("running-1")?.status).toBe("interrupted");
+    expect(mgr.getState("done-1")?.status).toBe("completed");
+
+    // Reachable by label and parent, like a live subagent.
+    expect(mgr.getByLabel("still-running", "parent-1")?.config.id).toBe(
+      "running-1",
+    );
+    expect(mgr.getChildrenOf("parent-1")).toHaveLength(2);
+
+    // The interrupted transition is persisted, so a second rehydrate is a no-op.
+    expect(
+      loadAllSubagentRecords().find((r) => r.id === "running-1")?.status,
+    ).toBe("interrupted");
+
+    mgr.disposeAll();
+  });
+
+  test("returns zero counts when there are no persisted records", () => {
+    const mgr = new SubagentManager();
+    expect(mgr.rehydrateFromDb()).toEqual({ rehydrated: 0, interrupted: 0 });
+    mgr.disposeAll();
+  });
+});

package/src/__tests__/subagent-spawn-and-await.test.ts

@@ -89,6 +89,7 @@ class FakeConversation {
     return undefined;
   }
   setAssistantId() {}
+  setEnabledPlugins() {}
   setSubagentAllowedTools() {}
   setPreactivatedSkillIds() {}
   getCurrentSystemPrompt() {

package/src/__tests__/subagent-terminal-message.test.ts

@@ -0,0 +1,99 @@
+import { describe, expect, test } from "bun:test";
+
+import { buildSubagentTerminalMessage } from "../subagent/manager.js";
+
+describe("buildSubagentTerminalMessage", () => {
+  test("inlines the final synthesis for a shared completed subagent", () => {
+    const msg = buildSubagentTerminalMessage({
+      label: "research-pricing",
+      subagentId: "sa-1",
+      isFork: false,
+      outcome: "completed",
+      silent: false,
+      finalText: "Competitor X charges $20/mo.",
+    });
+
+    expect(msg).toContain("Competitor X charges $20/mo.");
+    expect(msg).toContain("completed — result below");
+    expect(msg).toContain("Incorporate this into your reply");
+    // The whole point: no subagent_read round-trip, nothing left to re-spawn.
+    expect(msg).not.toContain("subagent_read");
+    expect(msg).not.toContain("re-spawn");
+  });
+
+  test("marks a silent completion for internal use only", () => {
+    const msg = buildSubagentTerminalMessage({
+      label: "scan",
+      subagentId: "sa-2",
+      isFork: true,
+      outcome: "completed",
+      silent: true,
+      finalText: "Internal findings.",
+    });
+
+    expect(msg).toContain("Internal findings.");
+    expect(msg).toContain("internally");
+    expect(msg).not.toContain("subagent_read");
+  });
+
+  test("falls back to a subagent_read pointer when there is no final text", () => {
+    const msg = buildSubagentTerminalMessage({
+      label: "empty-run",
+      subagentId: "sa-3",
+      isFork: false,
+      outcome: "completed",
+      silent: false,
+      finalText: "   ",
+    });
+
+    expect(msg).toContain("produced no final text");
+    expect(msg).toContain('subagent_read with subagent_id "sa-3"');
+    expect(msg).not.toContain("last_n");
+  });
+
+  test("fork fallback points at last_n: 1 and keeps it internal", () => {
+    const msg = buildSubagentTerminalMessage({
+      label: "empty-fork",
+      subagentId: "sa-4",
+      isFork: true,
+      outcome: "completed",
+      silent: true,
+      finalText: undefined,
+    });
+
+    expect(msg).toContain("last_n: 1");
+    expect(msg).toContain("Keep the result internal.");
+  });
+
+  test("keeps the read pointer instead of inlining when a follow-up turn is queued", () => {
+    const msg = buildSubagentTerminalMessage({
+      label: "interactive",
+      subagentId: "sa-6",
+      isFork: false,
+      outcome: "completed",
+      silent: false,
+      finalText: "Snapshot answer (stale).",
+      deferred: true,
+    });
+
+    // The snapshot must NOT be inlined — newer queued output is still coming.
+    expect(msg).not.toContain("Snapshot answer");
+    expect(msg).toContain("Queued follow-up guidance is still being processed");
+    expect(msg).toContain('subagent_read with subagent_id "sa-6"');
+  });
+
+  test("failure message surfaces the error and discourages auto-retry", () => {
+    const msg = buildSubagentTerminalMessage({
+      label: "broken",
+      subagentId: "sa-5",
+      isFork: false,
+      outcome: "failed",
+      silent: false,
+      error: "boom",
+    });
+
+    expect(msg).toContain('[Subagent "broken" failed]');
+    expect(msg).toContain("Error: boom");
+    expect(msg).toContain("Do NOT re-spawn or retry");
+  });
+});