@vellumai/assistant 0.11.3 → 0.11.4-dev.202608190019.b94dbf2

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__/scoped-approval-grants.test.ts

@@ -375,19 +375,24 @@ describe("scoped-approval-grants / expiry", () => {
   });
 
   test("already-consumed grants are not affected by expiry sweep", () => {
-    const _pastExpiry = Date.now() - 1_000;
+    const expiresAt = Date.now() + 60_000;
     createScopedApprovalGrant(
       grantParams({
         scopeMode: "request_id",
         requestId: "req-consumed",
-        expiresAt: Date.now() + 60_000,
+        expiresAt,
       }),
     );
-    consumeScopedApprovalGrantByRequestId("req-consumed", "c1");
+    const consumed = consumeScopedApprovalGrantByRequestId(
+      "req-consumed",
+      "c1",
+      expiresAt - 1,
+    );
+    expect(consumed.ok).toBe(true);
 
-    // Force the expiry time to the past for the consumed grant (simulating time passing)
-    // The sweep should not touch consumed grants
-    const count = expireScopedApprovalGrants();
+    // Sweep after the grant's expiresAt. Status is consumed, so the active-only
+    // expiry update must leave it alone.
+    const count = expireScopedApprovalGrants(expiresAt);
     expect(count).toBe(0);
   });
 });

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

@@ -62,7 +62,6 @@ function makeParams(
       sourceChannel: "slack" as const,
     } as any,
     replyCallbackUrl: undefined,
-    canonicalAssistantId: "self",
     ...overrides,
   };
 }

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__/skills.test.ts

@@ -825,6 +825,38 @@ describe("always-candidate frontmatter parsing", () => {
       .map(({ id, chars }) => `${id}: ${chars}`);
     expect(overrun).toEqual([]);
   });
+
+  test("the bundled acp skill's card fits the default budget", async () => {
+    // `acp` owns Claude Code and Codex setup, sign-in, and delegation, and the
+    // terms that route those turns to it live in this card. The card is
+    // hard-truncated at the default budget, so an overrun drops the trailing
+    // hints and the whole avoid-when list from what the selector sees.
+    const { DEFAULT_CARD_CHARS, buildSkillContent } =
+      await import("../plugins/defaults/memory/substrate/skill-content.js");
+    const acp = loadSkillCatalog().find((skill) => skill.id === "acp");
+    expect(acp).toBeDefined();
+
+    // A card that overran is cut to exactly the budget, so staying under it is
+    // what proves nothing was dropped. `avoid-when` is appended last and is
+    // therefore the first content a truncation eats.
+    const card = buildSkillContent(acp!);
+    expect(card.length).toBeLessThan(DEFAULT_CARD_CHARS);
+    expect(card).toContain("Avoid when:");
+  });
+
+  test("the bundled acp card carries its setup and sign-in vocabulary", async () => {
+    // A "configure Claude Code" or "let's do the auth" turn only reaches this
+    // skill if the card actually says it covers setup and authentication;
+    // delegation-only wording routes those turns to a terminal skill instead.
+    const { buildSkillContent } =
+      await import("../plugins/defaults/memory/substrate/skill-content.js");
+    const acp = loadSkillCatalog().find((skill) => skill.id === "acp");
+    const card = buildSkillContent(acp!).toLowerCase();
+
+    for (const term of ["set up", "install", "authenticate", "connect"]) {
+      expect(card).toContain(term);
+    }
+  });
 });
 
 describe("bundled skill categories", () => {

package/src/__tests__/slack-edit-ordering-characterization.test.ts

@@ -59,7 +59,6 @@ async function applyEdit(eventId: string, content: string): Promise<void> {
     conversationExternalId: CHANNEL,
     externalMessageId: eventId,
     sourceMessageId: ORIGINAL_TS,
-    canonicalAssistantId: "self",
     assistantId: "self",
     content,
   });

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-call-site-routing.test.ts

@@ -184,8 +184,11 @@ import {
   clearConversations,
   setConversation,
 } from "../daemon/conversation-registry.js";
+import type { TrustContext } from "../daemon/trust-context-types.js";
 import { CallSiteRoutingProvider } from "../providers/call-site-routing.js";
 import { SubagentManager } from "../subagent/manager.js";
+import { mockAuthContext } from "./helpers/mock-actor-context.js";
+import { asConversation } from "./helpers/mock-conversation.js";
 
 // Seed the workspace `llm` config per-case. The real loader schema-merges the
 // raw fragment over defaults exactly as the code path reads it.
@@ -304,26 +307,29 @@ describe("SubagentManager — provider call-site routing", () => {
   test("copies parent guardian and auth context into spawned conversation", async () => {
     setLlmConfig(makeLlmFixture());
 
-    const parentTrustContext = {
+    const parentTrustContext: TrustContext = {
       sourceChannel: "vellum",
       trustClass: "guardian",
       guardianPrincipalId: "guardian-1",
       guardianExternalUserId: "guardian-1",
     };
-    const parentAuthContext = {
+    const parentAuthContext = mockAuthContext({
       subject: "local:self:parent-perms",
       actorPrincipalId: "guardian-1",
-    };
+    });
 
     capturedConversations.length = 0;
     clearConversations();
     const manager = new SubagentManager();
-    setConversation("parent-perms", {
-      trustContext: parentTrustContext,
-      getAuthContext: () => parentAuthContext,
-      assistantId: "self",
-      getCurrentSystemPrompt: () => "parent system",
-    } as any);
+    setConversation(
+      "parent-perms",
+      asConversation({
+        trustContext: parentTrustContext,
+        getAuthContext: () => parentAuthContext,
+        assistantId: "self",
+        getCurrentSystemPrompt: () => "parent system",
+      }),
+    );
 
     await manager.spawn(
       {
@@ -354,11 +360,14 @@ describe("SubagentManager — provider call-site routing", () => {
     capturedConversations.length = 0;
     clearConversations();
     const manager = new SubagentManager();
-    setConversation("parent-scoped", {
-      enabledPlugins: parentScope,
-      getAuthContext: () => undefined,
-      getCurrentSystemPrompt: () => "parent system",
-    } as any);
+    setConversation(
+      "parent-scoped",
+      asConversation({
+        enabledPlugins: parentScope,
+        getAuthContext: () => undefined,
+        getCurrentSystemPrompt: () => "parent system",
+      }),
+    );
 
     await manager.spawn(
       {
@@ -383,11 +392,14 @@ describe("SubagentManager — provider call-site routing", () => {
     capturedConversations.length = 0;
     clearConversations();
     const manager = new SubagentManager();
-    setConversation("parent-unscoped", {
-      enabledPlugins: null,
-      getAuthContext: () => undefined,
-      getCurrentSystemPrompt: () => "parent system",
-    } as any);
+    setConversation(
+      "parent-unscoped",
+      asConversation({
+        enabledPlugins: null,
+        getAuthContext: () => undefined,
+        getCurrentSystemPrompt: () => "parent system",
+      }),
+    );
 
     await manager.spawn(
       {

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

@@ -207,6 +207,7 @@ import {
   setConversation,
 } from "../daemon/conversation-registry.js";
 import { SubagentAbortedError, SubagentManager } from "../subagent/manager.js";
+import { asConversation } from "./helpers/mock-conversation.js";
 
 function makeConfig(overrides: Record<string, unknown> = {}) {
   return {
@@ -229,16 +230,19 @@ function registerFakeParent(parentConversationId: string): {
   enqueuedCount: () => number;
 } {
   let enqueued = 0;
-  setConversation(parentConversationId, {
-    // Accessors read by setUpSubagent when copying trust/auth context.
-    trustContext: undefined,
-    getAuthContext: () => undefined,
-    assistantId: undefined,
-    enqueueMessage: () => {
-      enqueued += 1;
-      return { rejected: false, queued: true };
-    },
-  } as never);
+  setConversation(
+    parentConversationId,
+    asConversation({
+      // Accessors read by setUpSubagent when copying trust/auth context.
+      trustContext: undefined,
+      getAuthContext: () => undefined,
+      assistantId: undefined,
+      enqueueMessage: () => {
+        enqueued += 1;
+        return { rejected: false, queued: true, requestId: "req-fake" };
+      },
+    }),
+  );
   return { enqueuedCount: () => enqueued };
 }
 
@@ -585,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();
     }
   });