@vellumai/assistant 0.10.3 → 0.10.4-staging.1

package/src/__tests__/sse-actor-principal-guardian-source.test.ts

@@ -2,18 +2,16 @@
  * Regression: the SSE subscribe path must resolve the actor principal from the
  * SAME guardian source as the send/result routes.
  *
- * The send/result routes resolve the actor principal via the async,
- * gateway-first `findLocalGuardianPrincipalId`. The SSE eager-subscribe path
- * cannot await and uses the sync `findLocalGuardianPrincipalIdFromStore`. When
- * the gateway binding is canonical but the local contact row is stale/missing
- * (after a guardian reset or gateway-owned binding update), the sync path must
- * still land on the gateway principal — otherwise the event hub registers the
- * SSE client under a DIFFERENT principal than the turn/result paths use, and
- * targeted result submissions 403.
+ * The send/result routes resolve the actor principal via the async
+ * `findLocalGuardianPrincipalId`. The SSE eager-subscribe path cannot await and
+ * uses the sync `findLocalGuardianPrincipalIdFromStore`. Both read the
+ * gateway-owned guardian binding — async via the cached IPC read, sync via the
+ * IO-free cache snapshot — so the event hub registers the SSE client under the
+ * SAME principal the turn/result paths use; otherwise targeted result
+ * submissions 403.
  *
- * These tests pin the invariant by priming the gateway-delivery cache with a
- * principal that differs from the stale local store and asserting both
- * resolvers agree; and that a cold cache falls back to the local store.
+ * These tests pin the invariant by priming the gateway-delivery cache and
+ * asserting both resolvers agree; and that a cold cache yields no principal.
  */
 
 import { beforeEach, describe, expect, mock, test } from "bun:test";
@@ -30,17 +28,6 @@ mock.module("../ipc/gateway-client.js", () => ({
   resetPersistentClient: () => {},
 }));
 
-// ── Local store mock (the stale fallback source) ─────────────────────────────
-
-let storePrincipalId: string | undefined;
-
-mock.module("../contacts/contact-store.js", () => ({
-  findGuardianForChannel: (channelType: string) =>
-    storePrincipalId && channelType === "vellum"
-      ? { contact: { principalId: storePrincipalId }, channel: {} }
-      : null,
-}));
-
 import {
   __resetGuardianDeliveryCacheForTest,
   getGuardianDelivery,
@@ -62,31 +49,21 @@ describe("SSE actor principal resolves from the same guardian source as send/res
   beforeEach(() => {
     __resetGuardianDeliveryCacheForTest();
     ipcGuardians = [];
-    storePrincipalId = undefined;
   });
 
-  test("warm gateway cache: sync (SSE) and async (send/result) resolve the SAME principal despite a stale local store", async () => {
-    // Gateway binding is canonical; local store row is stale (different id).
+  test("warm gateway cache: sync (SSE) and async (send/result) resolve the SAME principal", async () => {
     ipcGuardians = [gatewayVellumGuardian];
-    storePrincipalId = "guardian-stale-local";
 
     // Prime the cache the way the async hot paths do.
     const asyncPrincipalId = await findLocalGuardianPrincipalId();
     expect(asyncPrincipalId).toBe("guardian-from-gateway");
 
-    // SSE's sync resolver reads the same cached gateway snapshot, NOT the
-    // stale store — so the principals match and host-proxy targeting works.
+    // SSE's sync resolver reads the same cached gateway snapshot — so the
+    // principals match and host-proxy targeting works.
     expect(findLocalGuardianPrincipalIdFromStore()).toBe(asyncPrincipalId);
   });
 
-  test("cold cache: sync resolver falls back to the local store as before", () => {
-    // Nothing primed the cache; only the local store has a binding.
-    storePrincipalId = "guardian-stale-local";
-
-    expect(findLocalGuardianPrincipalIdFromStore()).toBe("guardian-stale-local");
-  });
-
-  test("cold cache with no store binding: sync resolver returns undefined", () => {
+  test("cold cache: sync resolver returns undefined", () => {
     expect(findLocalGuardianPrincipalIdFromStore()).toBeUndefined();
   });
 

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

@@ -318,13 +318,12 @@ function makeContact(displayName: string): ContactWithChannels {
     id: `contact-${displayName.toLowerCase()}`,
     displayName,
     notes: null,
+    role: "contact",
     lastInteraction: null,
     interactionCount: 0,
     createdAt: now,
     updatedAt: now,
-    role: "contact",
     contactType: "human",
-    principalId: null,
     userFile: null,
     channels: [],
   };
@@ -345,7 +344,11 @@ describe("resolveCallHints", () => {
 
   test("guardian displayName for hints comes from the gateway binding", async () => {
     mockGuardianDelivery = [
-      { channelType: "phone", status: "active", displayName: "GatewayGuardian" },
+      {
+        channelType: "phone",
+        status: "active",
+        displayName: "GatewayGuardian",
+      },
     ];
 
     await resolveCallHints(null, []);

package/src/__tests__/subagent-fork-prompt-role.test.ts

@@ -0,0 +1,195 @@
+/**
+ * Tests for decoupling message-inheritance from prompt source and role on
+ * context-inheriting subagents (forks).
+ *
+ * A fork normally pins the parent's system prompt verbatim and keeps the
+ * `general` role so its KV cache stays aligned with the parent. These tests
+ * verify the opt-out paths: a fork may supply its own `systemPromptOverride`
+ * (which is used as-is and does NOT set `hasSystemPromptOverride`), and a fork
+ * may carry an explicit read-only role (whose tool allowlist is applied). A
+ * plain fork (no override, no role) must still behave exactly as before.
+ *
+ * The harness stubs `Conversation` and the spawn() dependencies so we can call
+ * `SubagentManager.spawn()` directly and capture the constructed conversation's
+ * system prompt, `hasSystemPromptOverride` flag, and allowed-tools set.
+ */
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+
+import type { ServerMessage } from "../daemon/message-protocol.js";
+
+// ── Captured constructor state ──────────────────────────────────────────────
+
+interface CapturedConversationState {
+  systemPrompt: string;
+  hasSystemPromptOverride: boolean;
+  allowedTools: Set<string> | undefined;
+}
+
+const capturedConversations: CapturedConversationState[] = [];
+
+// Stub Conversation so spawn() never runs an agent loop — we only inspect how
+// it was constructed and configured.
+class FakeConversation {
+  private readonly captured: CapturedConversationState;
+
+  constructor(
+    _id: string,
+    _provider: unknown,
+    systemPrompt: string,
+    _sendToClient: (msg: ServerMessage) => void,
+    _workingDir: string,
+    _options?: unknown,
+  ) {
+    this.captured = {
+      systemPrompt,
+      hasSystemPromptOverride: false,
+      allowedTools: undefined,
+    };
+    capturedConversations.push(this.captured);
+  }
+  set hasSystemPromptOverride(value: boolean) {
+    this.captured.hasSystemPromptOverride = value;
+  }
+  get hasSystemPromptOverride(): boolean {
+    return this.captured.hasSystemPromptOverride;
+  }
+  conversationType = "background";
+  updateClient() {}
+  setIsSubagent() {}
+  setTrustContext() {}
+  setAuthContext() {}
+  getAuthContext() {
+    return undefined;
+  }
+  setAssistantId() {}
+  setSubagentAllowedTools(tools: Set<string>) {
+    this.captured.allowedTools = tools;
+  }
+  setPreactivatedSkillIds() {}
+  injectInheritedContext() {}
+  abort() {}
+  dispose() {}
+  messages = [];
+  usageStats = { inputTokens: 0, outputTokens: 0, estimatedCost: 0 };
+  sendToClient() {}
+  persistUserMessage() {
+    return { id: "msg-id", deduplicated: false };
+  }
+  runAgentLoop() {
+    return Promise.resolve();
+  }
+  getCurrentSystemPrompt() {
+    return "resolved-parent-prompt";
+  }
+}
+
+mock.module("../daemon/conversation.js", () => ({
+  Conversation: FakeConversation,
+}));
+
+mock.module("../memory/conversation-bootstrap.js", () => ({
+  bootstrapConversation: () => ({ id: "conv-id" }),
+}));
+
+// Resolve a stub provider without touching connections/DB.
+const providerStub = { name: "anthropic", sendMessage: async () => ({}) };
+
+mock.module("../providers/connection-resolution.js", () => ({
+  resolveDefaultProvider: async () => providerStub,
+}));
+
+mock.module("../providers/call-site-routing.js", () => ({
+  wrapWithCallSiteRouting: (p: unknown) => p,
+}));
+
+mock.module("../config/loader.js", () => ({
+  getConfig: () => ({
+    llm: { default: { provider: "anthropic", model: "claude-opus-4-7" } },
+    rateLimit: { maxRequestsPerMinute: 0 },
+  }),
+}));
+
+mock.module("../config/llm-resolver.js", () => ({
+  resolveCallSiteConfig: () => ({ provider: "anthropic", maxTokens: 8192 }),
+}));
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, { get: () => () => {} }),
+}));
+
+// ── Imports (after mocks) ───────────────────────────────────────────────────
+
+import { clearConversations } from "../daemon/conversation-registry.js";
+import { SubagentManager } from "../subagent/manager.js";
+import type { SubagentConfig } from "../subagent/types.js";
+
+const PARENT_PROMPT = "You are the parent's system prompt.";
+
+type SpawnConfig = Omit<SubagentConfig, "id">;
+
+function makeForkSpawnConfig(
+  overrides: Partial<SpawnConfig> = {},
+): SpawnConfig {
+  return {
+    parentConversationId: `parent-${Math.random().toString(36).slice(2)}`,
+    label: "test fork",
+    objective: "do something",
+    fork: true,
+    parentSystemPrompt: PARENT_PROMPT,
+    ...overrides,
+  };
+}
+
+describe("SubagentManager fork — prompt source and role decoupling", () => {
+  let manager: SubagentManager;
+
+  beforeEach(() => {
+    clearConversations();
+    capturedConversations.length = 0;
+    manager = new SubagentManager();
+  });
+
+  afterEach(() => {
+    (manager as unknown as { stopSweep: () => void }).stopSweep();
+  });
+
+  /** Spawn a fork and return the single conversation that spawn() constructed. */
+  async function spawnFork(
+    overrides: Partial<SpawnConfig> = {},
+  ): Promise<CapturedConversationState> {
+    await manager.spawn(makeForkSpawnConfig(overrides), () => {});
+    const created = capturedConversations[0];
+    if (!created) throw new Error("Expected a subagent conversation");
+    return created;
+  }
+
+  test("fork with systemPromptOverride uses that prompt and does not set hasSystemPromptOverride", async () => {
+    const overridePrompt = "You are an advisor. Frame the context as advice.";
+    const created = await spawnFork({ systemPromptOverride: overridePrompt });
+
+    expect(created.systemPrompt).toBe(overridePrompt);
+    expect(created.hasSystemPromptOverride).toBe(false);
+  });
+
+  test("fork with explicit read-only role applies the role allowlist via setSubagentAllowedTools", async () => {
+    const created = await spawnFork({ role: "researcher" });
+
+    // The researcher role is read-only; its allowlist must be applied even for
+    // a fork.
+    expect(created.allowedTools).toBeInstanceOf(Set);
+    expect(created.allowedTools?.has("web_search")).toBe(true);
+    expect(created.allowedTools?.has("file_read")).toBe(true);
+    expect(created.allowedTools?.has("bash")).toBe(false);
+  });
+
+  test("plain fork (no override, no role) keeps parent prompt verbatim, general tools, and sets hasSystemPromptOverride", async () => {
+    const created = await spawnFork();
+
+    // Parent prompt verbatim, no tool filter (general role has no allowlist),
+    // and the prompt is pinned for KV-cache alignment.
+    expect(created.systemPrompt).toBe(PARENT_PROMPT);
+    expect(created.allowedTools).toBeUndefined();
+    expect(created.hasSystemPromptOverride).toBe(true);
+  });
+});

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

@@ -273,7 +273,7 @@ describe("SubagentManager fork spawn", () => {
     expect(memoryPolicy.includeDefaultFallback).toBe(true);
   });
 
-  test("fork forces general role and skips tool filtering", async () => {
+  test("fork defaults to general role (which has no tool allowlist)", async () => {
     const manager = new SubagentManager();
     const subagentId = "sub-fork-role";
 
@@ -286,14 +286,16 @@ describe("SubagentManager fork spawn", () => {
     fakeConversation.injectInheritedContext = () => {};
     fakeConversation.setSubagentAllowedTools = () => {};
 
-    // Create a fork state — in real spawn(), the role would be forced to
-    // "general" regardless of what was requested, and tool filtering skipped.
+    // A fork that does not request a role defaults to "general", which has
+    // `allowedTools: undefined` — so no tool filter is applied. (An explicit
+    // non-general role on a fork IS honored; that path is covered in
+    // subagent-fork-prompt-role.test.ts.)
     const state = makeState(
       subagentId,
       { isFork: true },
       {
         fork: true,
-        role: "general", // forced by spawn() logic
+        role: "general",
         parentMessages: FAKE_PARENT_MESSAGES,
         parentSystemPrompt: "Parent system prompt.",
       },
@@ -303,9 +305,6 @@ describe("SubagentManager fork spawn", () => {
 
     await asInternals(manager).runSubagent(subagentId, "Do something");
 
-    // Tool filtering is only applied in spawn(), not runSubagent(), so we
-    // verify the logic directly: forks skip setSubagentAllowedTools.
-    // For this test, we verify the fork's role is general (which has no allowedTools).
     expect(state.config.role).toBe("general");
 
     asInternals(manager).stopSweep();

package/src/__tests__/subagent-role-registry.test.ts

@@ -13,6 +13,7 @@ const ALL_ROLES: SubagentRole[] = [
   "coder",
   "planner",
   "investigator",
+  "advisor",
 ];
 
 describe("SUBAGENT_ROLE_REGISTRY", () => {
@@ -32,18 +33,30 @@ describe("SUBAGENT_ROLE_REGISTRY", () => {
     expect(SUBAGENT_ROLE_REGISTRY.general.allowedTools).toBeUndefined();
   });
 
-  test("all non-general roles have allowedTools as a non-empty array", () => {
+  test("all scoped tool-using roles have allowedTools as a non-empty array", () => {
     for (const role of ALL_ROLES) {
-      if (role === "general") continue;
+      // 'general' has no filter (undefined); 'advisor' is tool-less (empty).
+      if (role === "general" || role === "advisor") continue;
       const config = SUBAGENT_ROLE_REGISTRY[role];
       expect(Array.isArray(config.allowedTools)).toBe(true);
       expect(config.allowedTools!.length).toBeGreaterThan(0);
     }
   });
 
-  test('every role with allowedTools includes "notify_parent"', () => {
+  test("advisor is tool-less with an empty allowedTools array", () => {
+    const config = SUBAGENT_ROLE_REGISTRY.advisor;
+    expect(config.allowedTools).toEqual([]);
+  });
+
+  test("SubagentRole type includes advisor", () => {
+    const advisor: SubagentRole = "advisor";
+    expect(SUBAGENT_ROLE_REGISTRY[advisor]).toBeDefined();
+  });
+
+  test('every role with a non-empty allowlist includes "notify_parent"', () => {
     for (const [_role, config] of Object.entries(SUBAGENT_ROLE_REGISTRY)) {
-      if (config.allowedTools !== undefined) {
+      // 'advisor' is tool-less (empty allowlist) and intentionally has none.
+      if (config.allowedTools !== undefined && config.allowedTools.length > 0) {
         expect(config.allowedTools).toContain("notify_parent");
       }
     }