@vellumai/assistant 0.11.2 → 0.11.3-staging.2

package/src/__tests__/subagent-cron-run-attribution.test.ts

@@ -0,0 +1,301 @@
+/**
+ * Verifies that the schedule firing's `cron_runs.id` reaches the LLM work a
+ * scheduled turn delegates to subagents.
+ *
+ * A scheduled turn stamps every usage row it records with `cronRunId`, and
+ * schedule cost reporting attributes by that stamp. A subagent runs as its own
+ * child conversation, so unless the firing id is threaded through
+ * `ToolContext` → `SubagentConfig` → the child's `runAgentLoop`, the delegated
+ * spend records a null `cron_run_id` and drops out of the schedule's cost.
+ *
+ * The threading mirrors `overrideProfile`; the plumbing for that field is
+ * pinned by `agent-loop-override-profile.test.ts`.
+ */
+
+import { describe, expect, mock, test } from "bun:test";
+
+import type { ToolContext } from "../tools/types.js";
+import { setConfig } from "./helpers/set-config.js";
+
+interface CapturedRunAgentLoopOptions {
+  callSite?: string;
+  overrideProfile?: string;
+  forceOverrideProfile?: boolean;
+  cronRunId?: string | null;
+}
+
+const capturedRunAgentLoopOptions: CapturedRunAgentLoopOptions[] = [];
+
+// When set, `runAgentLoop` never settles, so the spawned subagent stays in a
+// non-terminal state and can accept a follow-up `sendMessage`.
+let holdRunAgentLoop = false;
+
+class FakeConversation {
+  constructor() {}
+  updateClient() {}
+
+  setTrustContext() {}
+  setAuthContext() {}
+  getAuthContext() {
+    return undefined;
+  }
+  setAssistantId() {}
+  setEnabledPlugins() {}
+  hasSystemPromptOverride = false;
+  setSubagentAllowedTools() {}
+  setSubagentDenySideEffects() {}
+  setSubagentSuppressParentNotifications() {}
+  setPreactivatedSkillIds() {}
+  preactivateSkills() {}
+  preactivateSkillsAsync() {}
+  setSpawnHints() {}
+  injectInheritedContext() {}
+  setActiveBranchId() {}
+  setBranchTag() {}
+  setForkPolicy() {}
+  setForkParentMessageCount() {}
+  setForkParentSystemPrompt() {}
+  enqueueMessage() {
+    return { rejected: false, queued: false };
+  }
+  abort() {}
+  dispose() {}
+  messages = [];
+  subagentDeniedToolNames: string[] = [];
+  usageStats = { inputTokens: 0, outputTokens: 0, estimatedCost: 0 };
+  sendToClient() {}
+  loadFromDb() {
+    return Promise.resolve();
+  }
+  persistUserMessage() {
+    return Promise.resolve({ id: "msg-id", deduplicated: false });
+  }
+  runAgentLoop(
+    _content: string,
+    _userMessageId: string,
+    options?: CapturedRunAgentLoopOptions,
+  ) {
+    capturedRunAgentLoopOptions.push({ ...(options ?? {}) });
+    if (holdRunAgentLoop) {
+      return new Promise<void>(() => {});
+    }
+    return Promise.resolve();
+  }
+  getCurrentSystemPrompt() {
+    return "system";
+  }
+}
+
+mock.module("../daemon/conversation.js", () => ({
+  Conversation: FakeConversation,
+}));
+
+mock.module("../persistence/conversation-bootstrap.js", () => ({
+  bootstrapConversation: () => ({ id: "conv-id" }),
+}));
+
+mock.module("../prompts/system-prompt.js", () => ({
+  buildSystemPrompt: () => "system prompt",
+  buildSubagentSystemPrompt: () => "subagent system",
+}));
+
+mock.module("../persistence/conversation-crud.js", () => ({
+  setConversationProcessingStartedAt: () => {},
+  getConversationOverrideProfile: () => undefined,
+  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
+}));
+
+const anthropicStub = { name: "anthropic" };
+
+mock.module("../providers/registry.js", () => ({
+  getProvider: () => anthropicStub,
+  listProviders: () => ["anthropic"],
+  initializeProviders: async () => {},
+  resolveProviderFromConnection: async () => anthropicStub,
+}));
+
+mock.module("../providers/inference/connections.js", () => ({
+  getConnection: (_db: unknown, name: string) => ({
+    id: 1,
+    name,
+    provider: "anthropic",
+    auth_strategy: "user_managed_credential",
+    credential_alias: null,
+    metadata_json: null,
+    created_at: new Date().toISOString(),
+    updated_at: new Date().toISOString(),
+  }),
+}));
+
+setConfig("llm", {
+  profiles: {
+    fast: {
+      source: "user",
+      provider: "anthropic",
+      model: "claude-haiku-4-5-20251001",
+    },
+  },
+  callSites: {},
+});
+
+// ── Imports (after mocks) ───────────────────────────────────────────────────
+
+import { getSubagentManager } from "../subagent/index.js";
+import { SubagentManager } from "../subagent/manager.js";
+import { executeSubagentSpawn } from "../tools/subagent/spawn.js";
+
+function toolContext(overrides: Partial<ToolContext>): ToolContext {
+  return {
+    workingDir: "/tmp",
+    conversationId: "conv-scheduled",
+    trustClass: "guardian",
+    sendToClient: () => {},
+    ...overrides,
+  } as ToolContext;
+}
+
+describe("executeSubagentSpawn: cronRunId forwarding", () => {
+  test("forwards the turn's cronRunId into the SubagentConfig", async () => {
+    const manager = getSubagentManager();
+    const originalSpawn = manager.spawn.bind(manager);
+    let capturedConfig: Record<string, unknown> | undefined;
+    manager.spawn = async (config: never) => {
+      capturedConfig = config;
+      return "subagent-cron-1";
+    };
+
+    try {
+      const result = await executeSubagentSpawn(
+        { label: "scheduled-child", objective: "do the delegated work" },
+        toolContext({ cronRunId: "cron-run-abc" }),
+      );
+
+      expect(result.isError).toBe(false);
+      expect(capturedConfig?.cronRunId).toBe("cron-run-abc");
+    } finally {
+      manager.spawn = originalSpawn;
+    }
+  });
+
+  test("omits cronRunId when the invoking turn was not triggered by a schedule", async () => {
+    const manager = getSubagentManager();
+    const originalSpawn = manager.spawn.bind(manager);
+    let capturedConfig: Record<string, unknown> | undefined;
+    manager.spawn = async (config: never) => {
+      capturedConfig = config;
+      return "subagent-cron-2";
+    };
+
+    try {
+      await executeSubagentSpawn(
+        { label: "interactive-child", objective: "do the delegated work" },
+        toolContext({ conversationId: "conv-interactive" }),
+      );
+
+      expect(capturedConfig).toBeDefined();
+      expect("cronRunId" in capturedConfig!).toBe(false);
+    } finally {
+      manager.spawn = originalSpawn;
+    }
+  });
+});
+
+describe("SubagentManager: cronRunId reaches the child's agent loop", () => {
+  test("passes the config's cronRunId into the spawned subagent's runAgentLoop", async () => {
+    capturedRunAgentLoopOptions.length = 0;
+
+    const manager = new SubagentManager();
+    await manager.spawn(
+      {
+        parentConversationId: "parent-cron-1",
+        label: "child",
+        objective: "do the thing",
+        cronRunId: "cron-run-abc",
+      },
+      () => {},
+    );
+
+    expect(capturedRunAgentLoopOptions).toHaveLength(1);
+    const captured = capturedRunAgentLoopOptions[0]!;
+    expect(captured.callSite).toBe("subagentSpawn");
+    expect(captured.cronRunId).toBe("cron-run-abc");
+  });
+
+  test("omits cronRunId when the SubagentConfig does not carry one", async () => {
+    capturedRunAgentLoopOptions.length = 0;
+
+    const manager = new SubagentManager();
+    await manager.spawn(
+      {
+        parentConversationId: "parent-cron-2",
+        label: "child",
+        objective: "do the thing",
+      },
+      () => {},
+    );
+
+    expect(capturedRunAgentLoopOptions).toHaveLength(1);
+    expect("cronRunId" in capturedRunAgentLoopOptions[0]!).toBe(false);
+  });
+
+  test("a continuation turn carries the messaging turn's cronRunId, not the spawn's", async () => {
+    capturedRunAgentLoopOptions.length = 0;
+    holdRunAgentLoop = true;
+
+    try {
+      const manager = new SubagentManager();
+      const subagentId = await manager.spawn(
+        {
+          parentConversationId: "parent-cron-3",
+          label: "child",
+          objective: "do the thing",
+          cronRunId: "cron-run-spawn",
+        },
+        () => {},
+      );
+      // The initial run is fire-and-forget; let it reach runAgentLoop.
+      await Promise.resolve();
+      await Promise.resolve();
+
+      const result = await manager.sendMessage(subagentId, "keep going", {
+        cronRunId: "cron-run-message",
+      });
+      expect(result).toBe("sent");
+
+      expect(capturedRunAgentLoopOptions).toHaveLength(2);
+      expect(capturedRunAgentLoopOptions[0]!.cronRunId).toBe("cron-run-spawn");
+      expect(capturedRunAgentLoopOptions[1]!.cronRunId).toBe(
+        "cron-run-message",
+      );
+    } finally {
+      holdRunAgentLoop = false;
+    }
+  });
+
+  test("omits cronRunId on a continuation turn no schedule triggered", async () => {
+    capturedRunAgentLoopOptions.length = 0;
+    holdRunAgentLoop = true;
+
+    try {
+      const manager = new SubagentManager();
+      const subagentId = await manager.spawn(
+        {
+          parentConversationId: "parent-cron-4",
+          label: "child",
+          objective: "do the thing",
+          cronRunId: "cron-run-spawn",
+        },
+        () => {},
+      );
+      await Promise.resolve();
+      await Promise.resolve();
+
+      await manager.sendMessage(subagentId, "keep going", { cronRunId: null });
+
+      expect(capturedRunAgentLoopOptions).toHaveLength(2);
+      expect("cronRunId" in capturedRunAgentLoopOptions[1]!).toBe(false);
+    } finally {
+      holdRunAgentLoop = false;
+    }
+  });
+});

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

@@ -33,6 +33,11 @@ interface FakeManagedSubagent {
       estimatedCost: number;
     };
     subagentDeniedToolNames: Set<string>;
+    subagentToolStats: {
+      calls: number;
+      succeeded: number;
+      filesWritten: Set<string>;
+    };
   } | null;
   state: SubagentState;
   parentSendToClient: (msg: AssistantEvent) => void;
@@ -64,6 +69,11 @@ function makeFakeConversation(): NonNullable<
     sendToClient: () => {},
     usageStats: { inputTokens: 100, outputTokens: 50, estimatedCost: 0.005 },
     subagentDeniedToolNames: new Set<string>(),
+    subagentToolStats: {
+      calls: 0,
+      succeeded: 0,
+      filesWritten: new Set<string>(),
+    },
   };
 }
 

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

@@ -52,6 +52,11 @@ interface FakeManagedSubagent {
       estimatedCost: number;
     };
     subagentDeniedToolNames: Set<string>;
+    subagentToolStats: {
+      calls: number;
+      succeeded: number;
+      filesWritten: Set<string>;
+    };
   } | null;
   state: SubagentState;
   parentSendToClient: (msg: AssistantEvent) => void;
@@ -82,6 +87,11 @@ function injectFakeSubagent(
     sendToClient: () => {},
     usageStats: { inputTokens: 100, outputTokens: 50, estimatedCost: 0.005 },
     subagentDeniedToolNames: new Set<string>(),
+    subagentToolStats: {
+      calls: 0,
+      succeeded: 0,
+      filesWritten: new Set<string>(),
+    },
   };
 
   const internals = asInternals(manager);

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

@@ -2,16 +2,22 @@
  * 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.
+ * A fork normally pins the parent's system prompt verbatim and runs on the
+ * default role, whose unrestricted surface matches the prompt it inherits, 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) keeps the parent's whole tool surface.
+ *
+ * A fork's persona is covered here too: the inherited prompt leaves
+ * `buildSubagentSystemPrompt` unused, so the persona reaches the child through
+ * its first message instead.
  *
  * 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.
+ * system prompt, `hasSystemPromptOverride` flag, allowed-tools set, and first
+ * user message.
  */
 import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
 
@@ -23,6 +29,8 @@ interface CapturedConversationState {
   systemPrompt: string;
   hasSystemPromptOverride: boolean;
   allowedTools: Set<string> | undefined;
+  /** Content of every user message the run persisted, in order. */
+  userMessages: string[];
 }
 
 const capturedConversations: CapturedConversationState[] = [];
@@ -44,6 +52,7 @@ class FakeConversation {
       systemPrompt,
       hasSystemPromptOverride: false,
       allowedTools: undefined,
+      userMessages: [],
     };
     capturedConversations.push(this.captured);
   }
@@ -72,7 +81,8 @@ class FakeConversation {
   messages = [];
   usageStats = { inputTokens: 0, outputTokens: 0, estimatedCost: 0 };
   sendToClient() {}
-  persistUserMessage() {
+  persistUserMessage(args: { content: string }) {
+    this.captured.userMessages.push(args.content);
     return { id: "msg-id", deduplicated: false };
   }
   runAgentLoop() {
@@ -154,6 +164,23 @@ describe("SubagentManager fork — prompt source and role decoupling", () => {
     return created;
   }
 
+  /**
+   * The first user message the run persisted. `spawn` fires the run without
+   * awaiting it, so the message lands a few ticks after spawn resolves.
+   */
+  async function firstUserMessage(
+    created: CapturedConversationState,
+  ): Promise<string> {
+    for (let attempt = 0; attempt < 50; attempt++) {
+      const first = created.userMessages[0];
+      if (first !== undefined) {
+        return first;
+      }
+      await new Promise((resolve) => setTimeout(resolve, 5));
+    }
+    throw new Error("Expected the subagent run to persist a user message");
+  }
+
   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 });
@@ -173,13 +200,60 @@ describe("SubagentManager fork — prompt source and role decoupling", () => {
     expect(created.allowedTools?.has("bash")).toBe(false);
   });
 
-  test("plain fork (no override, no role) keeps parent prompt verbatim, general tools, and sets hasSystemPromptOverride", async () => {
+  test("plain fork (no override, no role) keeps parent prompt verbatim, the parent's whole tool surface, 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.
+    // Parent prompt verbatim, no tool filter (the default role declares 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);
   });
+
+  test("a fork's persona reaches the child in its first message", async () => {
+    const created = await spawnFork({
+      role: "researcher",
+      persona: "financial journalist",
+    });
+    const first = await firstUserMessage(created);
+
+    // The system prompt is the parent's, so the message is the only carrier.
+    expect(created.systemPrompt).toBe(PARENT_PROMPT);
+    expect(created.systemPrompt).not.toContain("financial journalist");
+    expect(first).toContain("Act as financial journalist for this task.");
+    expect(first).toContain("do something");
+  });
+
+  test("a fork with no persona gets no persona line", async () => {
+    const created = await spawnFork();
+    const first = await firstUserMessage(created);
+
+    expect(first).toContain("FORK TASK");
+    expect(first).not.toContain("Act as");
+  });
+
+  test("a fork's output contract reaches the child in its first message", async () => {
+    const created = await spawnFork({
+      role: "researcher",
+      outputContract: "verdict",
+    });
+    const first = await firstUserMessage(created);
+
+    // Same carrier as the persona, and for the same reason: the system prompt
+    // is the parent's, so nothing the contract says can land there.
+    expect(created.systemPrompt).toBe(PARENT_PROMPT);
+    expect(created.systemPrompt).not.toContain("PASS or FAIL");
+    expect(first).toContain(
+      "Output contract: For each criterion in the objective return PASS or FAIL",
+    );
+    expect(first).toContain("do something");
+  });
+
+  test("a fork under the default report contract gets no contract line", async () => {
+    const created = await spawnFork({ outputContract: "report" });
+    const first = await firstUserMessage(created);
+
+    expect(first).toContain("FORK TASK");
+    expect(first).not.toContain("Output contract:");
+  });
 });

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

@@ -29,6 +29,11 @@ interface FakeManagedSubagent {
       estimatedCost: number;
     };
     subagentDeniedToolNames: Set<string>;
+    subagentToolStats: {
+      calls: number;
+      succeeded: number;
+      filesWritten: Set<string>;
+    };
   } | null;
   state: SubagentState;
   parentSendToClient: (msg: AssistantEvent) => void;
@@ -59,6 +64,11 @@ function makeFakeConversation(): NonNullable<
     sendToClient: () => {},
     usageStats: { inputTokens: 100, outputTokens: 50, estimatedCost: 0.005 },
     subagentDeniedToolNames: new Set<string>(),
+    subagentToolStats: {
+      calls: 0,
+      succeeded: 0,
+      filesWritten: new Set<string>(),
+    },
   };
 }
 
@@ -238,7 +248,7 @@ describe("SubagentManager fork spawn", () => {
     expect(resolvedSendResultToUser).toBeUndefined();
   });
 
-  test("fork defaults to general role (which has no tool allowlist)", async () => {
+  test("a fork that names no role carries none (no tool allowlist)", async () => {
     const manager = new SubagentManager();
     const subagentId = "sub-fork-role";
 
@@ -251,16 +261,14 @@ describe("SubagentManager fork spawn", () => {
     fakeConversation.injectInheritedContext = () => {};
     fakeConversation.setSubagentAllowedTools = () => {};
 
-    // 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.)
+    // A fork that names no role has none to apply, so no tool filter is
+    // applied and it keeps the parent's surface. (A named 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",
         parentMessages: FAKE_PARENT_MESSAGES,
         parentSystemPrompt: "Parent system prompt.",
       },
@@ -270,7 +278,7 @@ describe("SubagentManager fork spawn", () => {
 
     await asInternals(manager).runSubagent(subagentId, "Do something");
 
-    expect(state.config.role).toBe("general");
+    expect(state.config.role).toBeUndefined();
 
     asInternals(manager).stopSweep();
   });