@vellumai/assistant 0.11.4-staging.2 → 0.11.4-staging.3

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

@@ -40,6 +40,18 @@ mock.module("../daemon/conversation-store.js", () => ({
   },
 }));
 
+/**
+ * Whether the daemon activated the fixture plugin. Run-now answers only for
+ * plugins this process brought up, and no route test runs the plugin loader,
+ * so the double says "activated" unless a case turns it off.
+ */
+let pluginActivated = true;
+const realMtimeCache = await import("../plugins/mtime-cache.js");
+mock.module("../plugins/mtime-cache.js", () => ({
+  ...realMtimeCache,
+  isPluginDirActivated: () => pluginActivated,
+}));
+
 import type { AssistantEventEnvelope } from "../api/index.js";
 import { SYNC_TAGS } from "../daemon/message-types/sync.js";
 import {
@@ -1574,6 +1586,7 @@ describe("plugin-sourced schedules over routes", () => {
 
     beforeEach(() => {
       rmSync(RUN_MARKER, { force: true });
+      pluginActivated = true;
     });
 
     function seedSourcedScript() {
@@ -1626,6 +1639,16 @@ describe("plugin-sourced schedules over routes", () => {
       expect(existsSync(RUN_MARKER)).toBe(false);
     });
 
+    test("refuses a sourced row whose plugin the daemon never activated", async () => {
+      const sourced = await seedSourcedScript();
+      // The declaration is intact on disk, but nothing ran the plugin's
+      // `init`, so run-now must not execute its script.
+      pluginActivated = false;
+
+      await expect(runNow(sourced.id)).rejects.toThrow(BadRequestError);
+      expect(existsSync(RUN_MARKER)).toBe(false);
+    });
+
     test("runs a sourced row whose plugin is healthy", async () => {
       const sourced = await seedSourcedScript();
 

package/src/__tests__/schedule-store.test.ts

@@ -23,6 +23,7 @@ import {
 } from "../persistence/conversation-crud.js";
 import { getDb } from "../persistence/db-connection.js";
 import { initializeDb } from "../persistence/db-init.js";
+import { isPluginDirActivated } from "../plugins/mtime-cache.js";
 import { assistantEventHub } from "../runtime/assistant-event-hub.js";
 import {
   hasOwnerDeferProvenance,
@@ -1856,6 +1857,22 @@ describe("declared schedules", () => {
     expect(result!.enabled).toBe(false);
   });
 
+  test("enabling a schedule re-arms it on the on-disk declaration alone", async () => {
+    const created = await upsertDeclaredSchedule(SOURCE_KEY, makeDefinition());
+    await setUserEnabled(created.id, false);
+    // A schedule tool reaches this from a conversation turn, which can run in
+    // a sidecar worker process where no plugin is activated. The probe must
+    // therefore read the disk alone: asking about activation here would refuse
+    // every re-enable. Whether the plugin stays armed is the reconciler's
+    // call, and its next sweep disarms the row if it should not be.
+    expect(isPluginDirActivated(examplePluginDir())).toBe(false);
+
+    const result = await setUserEnabled(created.id, true);
+
+    expect(result!.userEnabled).toBe(true);
+    expect(result!.enabled).toBe(true);
+  });
+
   test("enabling a schedule whose plugin manifest is broken records the override without re-arming", async () => {
     const created = await upsertDeclaredSchedule(SOURCE_KEY, makeDefinition());
     await setUserEnabled(created.id, false);

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

@@ -155,7 +155,7 @@ const runAgentLoopMock = mock(async () => undefined);
 function makeSendMessageDeps() {
   const session = {
     setTrustContext: () => {},
-    updateClient: () => {},
+    replayActivityState: () => {},
     emitConfirmationStateChanged: () => {},
     emitActivityState: () => {},
     setTurnChannelContext: () => {},

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

@@ -130,7 +130,7 @@ function makeCompletingConversation(): Conversation {
     setTurnInterfaceContext: () => {},
     ensureActorScopedHistory: async () => {},
     usageStats: { inputTokens: 0, outputTokens: 0, estimatedCost: 0 },
-    updateClient: () => {},
+    replayActivityState: () => {},
     setHostBrowserProxy: () => {},
     setHostCuProxy: () => {},
     setHostAppControlProxy: () => {},
@@ -180,7 +180,7 @@ function makeHangingConversation(): Conversation {
     setTurnInterfaceContext: () => {},
     ensureActorScopedHistory: async () => {},
     usageStats: { inputTokens: 0, outputTokens: 0, estimatedCost: 0 },
-    updateClient: () => {},
+    replayActivityState: () => {},
     setHostBrowserProxy: () => {},
     setHostCuProxy: () => {},
     setHostAppControlProxy: () => {},
@@ -261,7 +261,7 @@ function makePendingApprovalConversation(
     setTurnInterfaceContext: () => {},
     ensureActorScopedHistory: async () => {},
     usageStats: { inputTokens: 0, outputTokens: 0, estimatedCost: 0 },
-    updateClient: () => {},
+    replayActivityState: () => {},
     setHostBrowserProxy: () => {},
     setHostCuProxy: () => {},
     setHostAppControlProxy: () => {},

package/src/__tests__/starter-task-flow.test.ts

@@ -39,10 +39,12 @@ import {
 } from "../daemon/conversation-surfaces.js";
 import { asConversation } from "./helpers/mock-conversation.js";
 
-function makeContext(): Conversation {
+function makeContext(
+  emit: (msg: AssistantEvent) => void = () => {},
+): Conversation {
   return asConversation({
     conversationId: "session-1",
-    sendToClient: () => {},
+    emit,
     pendingSurfaceActions: new Map<string, { surfaceType: SurfaceType }>(),
     lastSurfaceAction: new Map<
       string,
@@ -131,8 +133,7 @@ describe("starter task surface actions", () => {
 
   test("app_open registers dynamic_page surface as action-capable", async () => {
     const sent: AssistantEvent[] = [];
-    const ctx = makeContext();
-    ctx.sendToClient = (msg) => sent.push(msg);
+    const ctx = makeContext((msg) => sent.push(msg));
 
     const result = await surfaceProxyResolver(ctx, "app_open", {
       app_id: "test-app",

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

@@ -182,7 +182,7 @@ describe("SubagentManager fork — prompt source and role decoupling", () => {
   }
 
   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 overridePrompt = "You are a reviewer. Frame the context as review.";
     const created = await spawnFork({ systemPromptOverride: overridePrompt });
 
     expect(created.systemPrompt).toBe(overridePrompt);

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

@@ -589,20 +589,17 @@ describe("SubagentManager — first user message framing", () => {
     await manager.spawnAndAwait(
       makeConfig({
         objective: "Please advise.",
-        fork: true,
         role: "advisor",
+        spawnMode: "advisor_consult",
         // The advisor always supplies its own framing; setUpSubagent uses it
-        // verbatim and never falls back to parentSystemPrompt.
+        // in place of a built subagent preamble.
         systemPromptOverride: "You are a senior advisor.",
-        parentMessages: [
-          { role: "user", content: [{ type: "text", text: "prior turn" }] },
-        ],
       }),
       () => {},
     );
 
-    // The advisor's user turn is the bare advice request — the generic fork
-    // directive would fight the advisor system prompt.
+    // The consult is a regular blocking spawn, so its user turn is the brief
+    // itself: the fork directive would fight the advisor system prompt.
     expect(lastPersistedUserMessage).toBe("Please advise.");
     expect(lastPersistedUserMessage).not.toContain("FORK TASK");
   });

package/src/__tests__/subagent-tool-gate-mode.test.ts

@@ -118,7 +118,7 @@ function makeSetupCtx(overrides: Partial<Conversation> = {}): Conversation {
     workingDir: "/tmp/test",
     getTurnActorPrincipalId: () => undefined,
     abortController: null,
-    sendToClient: mock(() => {}),
+    emit: mock(() => {}),
     pendingSurfaceActions: new Map(),
     lastSurfaceAction: new Map(),
     surfaceState: new Map(),

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

@@ -1073,16 +1073,24 @@ describe("Subagent spawn repeat-loop guard", () => {
     const objective = "Audit the advisor pipeline for drift";
     seedSpawns("guard-advisor", objective, 6);
 
-    const { result } = await spawnWithGuard({
-      label: "Consult",
-      objective,
-      role: "advisor",
-    });
+    const manager = getSubagentManager();
+    const originalAwait = manager.spawnAndAwait.bind(manager);
+    manager.spawnAndAwait = (async () =>
+      "guidance") as unknown as typeof manager.spawnAndAwait;
+    try {
+      const { result } = await spawnWithGuard({
+        label: "Consult",
+        objective,
+        role: "advisor",
+      });
 
-    // The advisor branch runs and reports its own missing-parent notice, so the
-    // guard never saw the repetition.
-    expect(result.content).toContain("advisor unavailable");
-    expect(result.content).not.toContain("confirm_repeat");
+      // The advisor branch runs and returns its guidance, so the guard never
+      // saw the repetition.
+      expect(result.content).toBe("guidance");
+      expect(result.content).not.toContain("confirm_repeat");
+    } finally {
+      manager.spawnAndAwait = originalAwait;
+    }
   });
 
   test("copies still running trip the guard before any of them completes", async () => {
@@ -2831,19 +2839,27 @@ describe("Subagent output contract", () => {
   });
 
   test("a null contract reads as omitted and reaches the advisor branch", async () => {
-    const result = await executeSubagentSpawn(
-      {
-        label: "Consult",
-        objective: "Check the plan",
-        role: "advisor",
-        output_contract: null,
-      },
-      makeContext("sess-contract-advisor-none", { sendToClient: () => {} }),
-    );
-    // The advisor branch runs and reports its own missing-parent notice, so
-    // the contract check waved this spawn through.
-    expect(result.content).toContain("advisor unavailable");
-    expect(result.content).not.toContain("does not apply to the advisor");
+    const manager = getSubagentManager();
+    const originalAwait = manager.spawnAndAwait.bind(manager);
+    manager.spawnAndAwait = (async () =>
+      "guidance") as unknown as typeof manager.spawnAndAwait;
+    try {
+      const result = await executeSubagentSpawn(
+        {
+          label: "Consult",
+          objective: "Check the plan",
+          role: "advisor",
+          output_contract: null,
+        },
+        makeContext("sess-contract-advisor-none", { sendToClient: () => {} }),
+      );
+      // The advisor branch runs and returns its guidance, so the contract check
+      // waved this spawn through.
+      expect(result.content).toBe("guidance");
+      expect(result.content).not.toContain("does not apply to the advisor");
+    } finally {
+      manager.spawnAndAwait = originalAwait;
+    }
   });
 
   test("verdict defaults the child to the cost-optimized tier", async () => {
@@ -2998,7 +3014,6 @@ describe("Subagent output contract", () => {
 // ── Advisor-role consult ────────────────────────────────────────────
 
 describe("Subagent advisor-role consult", () => {
-  type Block = { type: string; [k: string]: unknown };
   type CapturedAwait = {
     config: Record<string, unknown>;
     opts?: {
@@ -3062,16 +3077,11 @@ describe("Subagent advisor-role consult", () => {
       expect(result.content).toBe("Here is my advice.");
       // Ran synchronously through spawnAndAwait, not fire-and-forget spawn.
       expect(captured.current).toBeDefined();
-      expect(captured.current!.config.fork).toBe(true);
       expect(captured.current!.config.role).toBe("advisor");
       // The advisor is a ROLE, not an `LLMCallSiteEnum` value, so its usage
       // lands under `subagentSpawn` like any other subagent. The declared
-      // spawn mode is what separates it from a plain fork in cost telemetry.
+      // spawn mode is what separates it from a plain spawn in cost telemetry.
       expect(captured.current!.config.spawnMode).toBe("advisor_consult");
-      // Framing embeds the executor prompt as advisor system prompt context.
-      expect(captured.current!.config.systemPromptOverride).toContain(
-        "PARENT SYSTEM PROMPT",
-      );
       // The situational context pack must never ride display surfaces: the
       // system prompt stays minimal and `objective` (rendered verbatim by the
       // subagent detail panel) stays the concise advice request. Only the
@@ -3089,26 +3099,18 @@ describe("Subagent advisor-role consult", () => {
     }
   });
 
-  test("advisor inherits and sanitizes the parent transcript", async () => {
-    // Parent in-memory history carries a thinking block (must be stripped) and
-    // a completed tool_use/tool_result pair (must be preserved).
+  test("advisor carries no parent transcript or system prompt", async () => {
+    // The consult is a regular blocking spawn: the brief is its whole input, so
+    // nothing of the parent conversation is snapshotted into it.
     mockFindConversation = () => ({
       messages: [
         { role: "user", content: [{ type: "text", text: "Do the task" }] },
         {
           role: "assistant",
-          content: [
-            { type: "thinking", thinking: "secret reasoning" },
-            { type: "text", text: "Working on it" },
-            { type: "tool_use", id: "t1", name: "bash", input: {} },
-          ],
-        },
-        {
-          role: "user",
-          content: [{ type: "tool_result", tool_use_id: "t1", content: "ok" }],
+          content: [{ type: "text", text: "Working on it" }],
         },
       ],
-      getCurrentSystemPrompt: () => "SYS",
+      getCurrentSystemPrompt: () => "PARENT SYSTEM PROMPT",
     });
     const { captured, restore } = stubAwait("advice");
     try {
@@ -3116,77 +3118,55 @@ describe("Subagent advisor-role consult", () => {
         { label: "Consult", objective: "x", role: "advisor" },
         makeContext("advisor-sess-2", { sendToClient: () => {} }),
       );
-      const msgs = captured.current!.config.parentMessages as Array<{
-        role: string;
-        content: Block[];
-      }>;
-      const allBlocks = msgs.flatMap((m) => m.content);
-      // Thinking is stripped; the completed tool_use/tool_result pair survives.
-      expect(allBlocks.some((b) => b.type === "thinking")).toBe(false);
-      expect(allBlocks.some((b) => b.type === "tool_use")).toBe(true);
-      expect(allBlocks.some((b) => b.type === "tool_result")).toBe(true);
+      expect(captured.current!.config.fork).toBeUndefined();
+      expect(captured.current!.config.parentMessages).toBeUndefined();
+      expect(captured.current!.config.parentSystemPrompt).toBeUndefined();
+      expect(captured.current!.config.systemPromptOverride).not.toContain(
+        "PARENT SYSTEM PROMPT",
+      );
     } finally {
       restore();
       mockFindConversation = () => undefined;
     }
   });
 
-  test("in-flight plan is visible to the advisor with no dangling tool_use", async () => {
-    // The in-memory snapshot ends on the user turn — the in-flight assistant
-    // turn (this turn's plan + the pending advisor tool_use) lives only in the
-    // DB at consult time. It must be appended, and its dangling tool_use stripped.
-    mockFindConversation = () => ({
-      messages: [
-        { role: "user", content: [{ type: "text", text: "Plan the work" }] },
-      ],
-      getCurrentSystemPrompt: () => "SYS",
-    });
-    mockGetMessages = (convId: string) => {
-      if (convId !== "advisor-sess-3") {
-        return null;
-      }
-      return [
-        {
-          role: "user",
-          content: [{ type: "text", text: "Plan the work" }],
-        },
-        {
-          role: "assistant",
-          content: [
-            { type: "text", text: "My plan: step 1, step 2." },
-            {
-              type: "tool_use",
-              id: "adv-1",
-              name: "subagent_spawn",
-              input: {},
-            },
-          ],
-        },
-      ];
-    };
+  test("the agent's objective reaches the advisor as its brief", async () => {
+    // The brief is the advisor's only account of the work, so it must travel
+    // verbatim inside the request fence.
+    const brief = [
+      "Task: migrate the queue to the new store.",
+      "Plan: dual-write, then cut over.",
+      "Evidence: src/queue/store.ts already exports both writers.",
+      "Question: is dual-write the right shape here?",
+    ].join("\n");
     const { captured, restore } = stubAwait("advice");
     try {
       await executeSubagentSpawn(
-        { label: "Consult", objective: "x", role: "advisor" },
-        makeContext("advisor-sess-3", { sendToClient: () => {} }),
+        { label: "Consult", objective: brief, role: "advisor" },
+        makeContext("advisor-sess-brief", { sendToClient: () => {} }),
+      );
+      expect(captured.current!.config.requestText).toContain(
+        `<agent_request>\n${brief}\n</agent_request>`,
       );
-      const msgs = captured.current!.config.parentMessages as Array<{
-        role: string;
-        content: Block[];
-      }>;
-      const allBlocks = msgs.flatMap((m) => m.content);
-      // The plan text the model wrote this turn is present in the consult.
-      expect(
-        allBlocks.some(
-          (b) => b.type === "text" && b.text === "My plan: step 1, step 2.",
-        ),
-      ).toBe(true);
-      // No dangling tool_use is sent.
-      expect(allBlocks.some((b) => b.type === "tool_use")).toBe(false);
     } finally {
       restore();
-      mockFindConversation = () => undefined;
-      mockGetMessages = () => null;
+    }
+  });
+
+  test("advisor consults still run when the parent conversation is gone", async () => {
+    // The parent is looked up only for its warm skill catalog, so an evicted
+    // conversation costs a section of the context pack, not the consult.
+    mockFindConversation = () => undefined;
+    const { captured, restore } = stubAwait("advice");
+    try {
+      const result = await executeSubagentSpawn(
+        { label: "Consult", objective: "advise me", role: "advisor" },
+        makeContext("advisor-sess-no-parent", { sendToClient: () => {} }),
+      );
+      expect(result.content).toBe("advice");
+      expect(captured.current!.config.role).toBe("advisor");
+    } finally {
+      restore();
     }
   });
 

package/src/__tests__/surface-completion-in-flight-snapshot.test.ts

@@ -104,6 +104,7 @@ function makeContext(): Conversation {
     conversationId: CONVERSATION_ID,
     trustContext: { trustClass: "guardian", sourceChannel: "vellum" },
     sendToClient: () => {},
+    emit: () => {},
     pendingSurfaceActions: new Map<string, { surfaceType: SurfaceType }>(),
     lastSurfaceAction: new Map(),
     surfaceState: new Map(),

package/src/__tests__/ui-choice-copy-surfaces.test.ts

@@ -22,7 +22,7 @@ import { asConversation } from "./helpers/mock-conversation.js";
 function makeContext(sent: AssistantEvent[] = []): Conversation {
   return asConversation({
     conversationId: "session-1",
-    sendToClient: (msg) => sent.push(msg),
+    emit: (msg) => sent.push(msg),
     pendingSurfaceActions: new Map<string, { surfaceType: SurfaceType }>(),
     lastSurfaceAction: new Map<
       string,

package/src/__tests__/ui-visual-surface.test.ts

@@ -32,7 +32,7 @@ const HTML = '<div style="color:var(--content-default)">Hello</div>';
 function makeContext(sent: AssistantEvent[] = []): Conversation {
   return asConversation({
     conversationId: "session-1",
-    sendToClient: (msg) => sent.push(msg),
+    emit: (msg) => sent.push(msg),
     pendingSurfaceActions: new Map<string, { surfaceType: SurfaceType }>(),
     lastSurfaceAction: new Map<
       string,

package/src/__tests__/ui-voice-picker-surface.test.ts

@@ -26,7 +26,7 @@ import { asConversation } from "./helpers/mock-conversation.js";
 function makeContext(sent: AssistantEvent[] = []): Conversation {
   return asConversation({
     conversationId: "session-1",
-    sendToClient: (msg) => sent.push(msg),
+    emit: (msg) => sent.push(msg),
     pendingSurfaceActions: new Map<string, { surfaceType: SurfaceType }>(),
     lastSurfaceAction: new Map<
       string,

package/src/__tests__/ui-work-result-surface.test.ts

@@ -19,7 +19,7 @@ import { asConversation } from "./helpers/mock-conversation.js";
 function makeContext(sent: AssistantEvent[] = []): Conversation {
   return asConversation({
     conversationId: "session-1",
-    sendToClient: (msg) => sent.push(msg),
+    emit: (msg) => sent.push(msg),
     pendingSurfaceActions: new Map<string, { surfaceType: SurfaceType }>(),
     lastSurfaceAction: new Map<
       string,

package/src/__tests__/voice-scoped-grant-consumer.test.ts

@@ -89,7 +89,8 @@ const CALL_SESSION_ID = "call-session-voice-grant-test";
 
 /**
  * Create a mock session that, when runAgentLoop is called, emits a
- * confirmation_request through the updateClient callback before completing.
+ * confirmation_request through the registered event observer before
+ * completing.
  */
 function createMockSession(opts?: {
   confirmationRequestId?: string;
@@ -118,8 +119,9 @@ function createMockSession(opts?: {
     currentRequestId: requestId,
     abort: () => {},
     persistUserMessage: async () => ({ id: "msg-1", deduplicated: false }),
-    updateClient: (cb: (msg: AssistantEvent) => void, _reset?: boolean) => {
+    addEventObserver: (cb: (msg: AssistantEvent) => void) => {
       clientCallback = cb;
+      return () => {};
     },
     handleConfirmationResponse: (
       reqId: string,
@@ -138,7 +140,7 @@ function createMockSession(opts?: {
       _messageId: string,
       options?: { onEvent?: (msg: AssistantEvent) => void },
     ) => {
-      // Emit a confirmation_request through the client callback
+      // Emit a confirmation_request through the event observer
       if (clientCallback) {
         clientCallback({
           type: "confirmation_request",