@vellumai/assistant 0.12.2-dev.202609171913.b5e95d3 → 0.12.2-dev.202609172115.0b9be8f

package/node_modules/@vellumai/slack-text/src/index.ts

@@ -127,7 +127,7 @@ export async function buildSlackUserLabelMap(
     ids.map(async (id): Promise<[string, string] | undefined> => {
       try {
         const label = await resolveLabel(id);
-        const sanitized = sanitizeOptionalLabel(label ?? undefined);
+        const sanitized = sanitizeSlackLabel(label ?? undefined);
         if (!sanitized || sanitized === id) return undefined;
         return [id, sanitized];
       } catch {
@@ -166,7 +166,7 @@ export async function buildSlackChannelLabelMap(
     ids.map(async (id): Promise<[string, string] | undefined> => {
       try {
         const label = await resolveLabel(id);
-        const sanitized = sanitizeOptionalLabel(label ?? undefined);
+        const sanitized = sanitizeSlackLabel(label ?? undefined);
         if (!sanitized || sanitized === id) return undefined;
         return [id, sanitized];
       } catch {
@@ -222,7 +222,7 @@ function renderChannelReference(
     return `#${embeddedLabel}`;
   }
 
-  const resolvedLabel = sanitizeOptionalLabel(
+  const resolvedLabel = sanitizeSlackLabel(
     options.channelLabels?.[channelId],
   );
   if (resolvedLabel && resolvedLabel !== channelId) {
@@ -320,15 +320,11 @@ export function sanitizeSlackLabel(
 function sanitizeEmbeddedSlackLabel(
   label: string | undefined,
 ): string | undefined {
-  return sanitizeOptionalLabel(
+  return sanitizeSlackLabel(
     label === undefined ? undefined : decodeSlackHtmlEntities(label),
   );
 }
 
-function sanitizeOptionalLabel(label: string | undefined): string | undefined {
-  return sanitizeSlackLabel(label);
-}
-
 function isSlackUserId(value: string): boolean {
   return /^[UW][A-Z0-9]+$/.test(value);
 }

package/openapi.yaml

@@ -16556,7 +16556,7 @@ paths:
             type: string
           description:
             "Filter by provider id. One of: anthropic, openai, gemini, ollama, fireworks, together, openrouter,
-            vercel-ai-gateway, litellm, opencode, openai-compatible, minimax, atlascloud, baseten, poolside, jev,
+            vercel-ai-gateway, litellm, opencode, openai-compatible, minimax, atlascloud, baseten, poolside, typesafe,
             vellum"
       responses:
         "200":
@@ -16829,7 +16829,7 @@ paths:
             type: string
           description:
             "Filter by provider. One of: anthropic, openai, gemini, ollama, fireworks, together, openrouter,
-            vercel-ai-gateway, litellm, opencode, openai-compatible, minimax, atlascloud, baseten, poolside, jev,
+            vercel-ai-gateway, litellm, opencode, openai-compatible, minimax, atlascloud, baseten, poolside, typesafe,
             vellum, chatgpt"
       responses:
         "200":
@@ -38400,7 +38400,7 @@ components:
         - atlascloud
         - baseten
         - poolside
-        - jev
+        - typesafe
         - vellum
         - chatgpt
     Auth:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.12.2-dev.202609171913.b5e95d3",
+  "version": "0.12.2-dev.202609172115.0b9be8f",
   "license": "MIT",
   "type": "module",
   "exports": {

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

@@ -338,7 +338,7 @@ describe("POST /v1/btw", () => {
     expect(options!.config!.modelIntent).toBeUndefined();
   });
 
-  test("greeting requests pass callSite: 'emptyStateGreeting'", async () => {
+  test("greeting requests pass callSite: 'emptyStateGreeting' and send no tools", async () => {
     const provider = makeMockProvider();
     const session = makeMockSession(provider);
     mockGetOrCreateConversation.mockImplementationOnce(async () => session);
@@ -352,6 +352,9 @@ describe("POST /v1/btw", () => {
     expect(provider.sendMessage).toHaveBeenCalledTimes(1);
     const [, options] = provider.sendMessage.mock.calls[0];
     expect(options!.config!.callSite).toBe("emptyStateGreeting");
+    // The greeting targets no real conversation, so there is no cache prefix
+    // for tool definitions to share; they would only cost tokens.
+    expect(options!.tools).toEqual([]);
   });
 
   test("greeting requests include fresh turn context using the client timezone", async () => {

package/src/__tests__/conversation-runtime-assembly.test.ts

@@ -673,6 +673,35 @@ describe("injectChannelCapabilityContext", () => {
     const text = (result.content[0] as { type: "text"; text: string }).text;
     expect(text).not.toContain("Do NOT use markdown tables");
   });
+
+  test("injects email send CLI constraint for email channel", () => {
+    const caps: ChannelCapabilities = {
+      channel: "email",
+      dashboardCapable: false,
+      supportsDynamicUi: false,
+      supportsVoiceInput: false,
+    };
+
+    const result = injectChannelCapabilityContext(baseUserMessage, caps);
+    const text = (result.content[0] as { type: "text"; text: string }).text;
+    expect(text).toContain("Conversation text is not emailed");
+    expect(text).toContain("assistant email send");
+    expect(text).toContain("--reply-to");
+  });
+
+  test("does NOT inject email send CLI constraint for non-email channels", () => {
+    const caps: ChannelCapabilities = {
+      channel: "telegram",
+      dashboardCapable: false,
+      supportsDynamicUi: false,
+      supportsVoiceInput: false,
+    };
+
+    const result = injectChannelCapabilityContext(baseUserMessage, caps);
+    const text = (result.content[0] as { type: "text"; text: string }).text;
+    expect(text).not.toContain("Conversation text is not emailed");
+    expect(text).not.toContain("assistant email send");
+  });
 });
 
 // ---------------------------------------------------------------------------

package/src/__tests__/inference-profile-session-handler.test.ts

@@ -389,7 +389,7 @@ describe("setInferenceProfileSession", () => {
       profiles: {
         jev: {
           source: "user",
-          provider: "jev",
+          provider: "typesafe",
           model: "jev-latest",
           status: "active",
         },

package/src/__tests__/llm-catalog-parity.test.ts

@@ -234,12 +234,12 @@ describe("LLM catalog parity: daemon vs client", () => {
   });
 
   test("jev-latest opts out of chat text generation", () => {
-    expect(catalogModelSupportsText("jev", "jev-latest")).toBe(false);
+    expect(catalogModelSupportsText("typesafe", "jev-latest")).toBe(false);
     expect(catalogModelSupportsText("anthropic", "claude-opus-4-8")).toBe(true);
     expect(catalogModelSupportsText("openai-compatible", "local-model")).toBe(
       true,
     );
-    expect(DEFAULT_PROVIDER_CHOICES).not.toContain("jev");
+    expect(DEFAULT_PROVIDER_CHOICES).not.toContain("typesafe");
     expect(DEFAULT_PROVIDER_CHOICES).toContain("poolside");
   });
 

package/src/config/__tests__/default-provider.test.ts

@@ -73,7 +73,9 @@ describe("LLMSchema.defaultProvider", () => {
   });
 
   test("rejects a structured-decision catalog provider", () => {
-    expect(() => DefaultProviderSchema.parse({ provider: "jev" })).toThrow();
+    expect(() =>
+      DefaultProviderSchema.parse({ provider: "typesafe" }),
+    ).toThrow();
   });
 
   test("rejects an empty connectionName", () => {

package/src/config/__tests__/memory-retrospective-schema.test.ts

@@ -12,10 +12,11 @@ import { describe, expect, test } from "bun:test";
 import { MemoryRetrospectiveConfigSchema } from "../schemas/memory-retrospective.js";
 
 describe("memory.retrospective config schema", () => {
-  test("an empty block leaves retrospectives and skill improvement on", () => {
+  test("an empty block leaves skill improvement on and monitoring off", () => {
     const parsed = MemoryRetrospectiveConfigSchema.parse({});
     expect(parsed.enabled).toBe(true);
     expect(parsed.skillImprovement).toBe(true);
+    expect(parsed.skillImprovementMonitoring).toBe(false);
     expect(parsed).not.toHaveProperty("forkStrategy");
   });
 
@@ -41,6 +42,18 @@ describe("memory.retrospective config schema", () => {
     ).toBe(false);
   });
 
+  test("skillImprovementMonitoring is a boolean-only opt-in", () => {
+    const parsed = MemoryRetrospectiveConfigSchema.parse({
+      skillImprovementMonitoring: true,
+    });
+    expect(parsed.skillImprovementMonitoring).toBe(true);
+    expect(
+      MemoryRetrospectiveConfigSchema.safeParse({
+        skillImprovementMonitoring: "true",
+      }).success,
+    ).toBe(false);
+  });
+
   test("a leftover forkStrategy key is ignored", () => {
     const parsed = MemoryRetrospectiveConfigSchema.parse({
       forkStrategy: "cloning",

package/src/config/bundled-skills/sequences/TOOLS.json

@@ -165,11 +165,7 @@
             },
             "description": "Replacement steps (replaces all existing steps)"
           }
-        },
-        "oneOf": [
-          { "required": ["id"] },
-          { "required": ["enrollment_id", "enrollment_action"] }
-        ]
+        }
       },
       "executor": "tools/sequence-update.ts",
       "execution_target": "host"

package/src/config/profile-text-generation.test.ts

@@ -9,7 +9,7 @@ describe("profileSupportsTextGeneration", () => {
   test("false for a structured-decision catalog model", () => {
     expect(
       profileSupportsTextGeneration(
-        { provider: "jev", model: "jev-latest" },
+        { provider: "typesafe", model: "jev-latest" },
         {},
       ),
     ).toBe(false);
@@ -35,7 +35,7 @@ describe("profileSupportsTextGeneration", () => {
       profileSupportsTextGeneration(
         { mix: [{ profile: "jev" }, { profile: "balanced" }] },
         {
-          jev: { provider: "jev", model: "jev-latest" },
+          jev: { provider: "typesafe", model: "jev-latest" },
           balanced: { provider: "anthropic", model: "claude-opus-4-8" },
         },
       ),

package/src/config/schemas/llm.ts

@@ -62,7 +62,7 @@ export const KNOWN_LLM_PROVIDERS = [
   "opencode",
   "baseten",
   "poolside",
-  "jev",
+  "typesafe",
   // Routing identities: "vellum" = the platform-managed route (upstream
   // derived from the model at dispatch) and the catalog owner of
   // Vellum-hosted GPU models; "chatgpt" = the subscription route to OpenAI.

package/src/config/schemas/memory-retrospective.ts

@@ -11,14 +11,23 @@ export const MemoryRetrospectiveConfigSchema = z
 
     skillImprovement: z
       .boolean({
-        error:
-          "memory.retrospective.skillImprovement must be a boolean",
+        error: "memory.retrospective.skillImprovement must be a boolean",
       })
       .default(true)
       .describe(
         "Whether retrospectives may discover, refine, and create managed skills from observed procedures. When false, retrospectives still capture ordinary memories through `remember`, but cannot load skill management, search for similar skills, or scaffold managed skills.",
       ),
 
+    skillImprovementMonitoring: z
+      .boolean({
+        error:
+          "memory.retrospective.skillImprovementMonitoring must be a boolean",
+      })
+      .default(false)
+      .describe(
+        "Reserved opt-in for monitoring retrospective skill-improvement decisions. This setting currently has no effect.",
+      ),
+
     timeThresholdMs: z
       .number({
         error: "memory.retrospective.timeThresholdMs must be a number",

package/src/daemon/conversation-runtime-assembly.ts

@@ -903,6 +903,11 @@ export function buildChannelCapabilityBlock(
         "- Do NOT use markdown tables — use bullet lists instead. No markdown headers — use **bold** or CAPS for emphasis.",
       );
     }
+    if (caps.channel === "email") {
+      lines.push(
+        "- Conversation text is not emailed. To reply, run `assistant email send` (see `assistant email send --help`). Use `--reply-to` to keep the thread. Skip a reply only when none is needed.",
+      );
+    }
   }
 
   // Inject group chat etiquette only when the chat type indicates a multi-party
@@ -2035,20 +2040,6 @@ export async function composeInjectorChain(ctx: TurnContext): Promise<string> {
  */
 const DEFAULT_PLACEMENT: InjectionPlacement = "append-user-tail";
 
-/**
- * Count leading memory-prefix blocks on a user message's `content`.
- *
- * Delegates to {@link countMemoryPrefixBlocks} from
- * `memory/graph/conversation-graph-memory.js` — the canonical state-machine
- * for locating the memory-prefix boundary. Reusing it here keeps the
- * PKB-context / PKB-reminder / NOW splice rules aligned on a single source
- * of truth so their ordering relative to any memory prefix is stable and
- * testable.
- */
-function countMemoryPrefixBlocksOnContent(content: ContentBlock[]): number {
-  return countMemoryPrefixBlocks(content);
-}
-
 /**
  * Apply one injector block to a `runMessages` array according to its
  * declared {@link InjectionPlacement}:
@@ -2101,9 +2092,7 @@ function applyInjectionBlock(
         { ...userTail, content: [...userTail.content, textBlock] },
       ];
     case "after-memory-prefix": {
-      const memoryPrefixCount = countMemoryPrefixBlocksOnContent(
-        userTail.content,
-      );
+      const memoryPrefixCount = countMemoryPrefixBlocks(userTail.content);
       return [
         ...runMessages.slice(0, -1),
         {
@@ -2161,7 +2150,7 @@ function stripTailV2DynamicMemoryPrefix(
   if (!last || last.role !== "user") {
     return messages;
   }
-  const prefixCount = countMemoryPrefixBlocksOnContent(last.content);
+  const prefixCount = countMemoryPrefixBlocks(last.content);
   if (prefixCount === 0) {
     return messages;
   }

package/src/mcp/__tests__/manager-tool-caps.test.ts

@@ -10,7 +10,8 @@ import { beforeEach, describe, expect, mock, test } from "bun:test";
 import type { ResolvedMcpConfig } from "../../config/schemas/mcp.js";
 
 const toolsByServer = new Map<string, Array<{ name: string }>>();
-const connectDelays = new Map<string, number>();
+const connectGates = new Map<string, Promise<void>>();
+const listedServers = new Set<string>();
 let mcpGlobalMaxTools: number | undefined;
 
 mock.module("../../config/loader.js", () => ({
@@ -29,12 +30,13 @@ mock.module("../client.js", () => ({
       return null;
     }
     async connect() {
-      const delay = connectDelays.get(this.serverId) ?? 0;
-      if (delay > 0) {
-        await new Promise((resolve) => setTimeout(resolve, delay));
+      const gate = connectGates.get(this.serverId);
+      if (gate) {
+        await gate;
       }
     }
     async listTools() {
+      listedServers.add(this.serverId);
       return (toolsByServer.get(this.serverId) ?? []).map((tool) => ({
         name: tool.name,
         description: `${this.serverId} ${tool.name}`,
@@ -66,7 +68,8 @@ function configWith(ids: string[]): ResolvedMcpConfig {
 describe("McpServerManager tool selection", () => {
   beforeEach(() => {
     toolsByServer.clear();
-    connectDelays.clear();
+    connectGates.clear();
+    listedServers.clear();
     mcpGlobalMaxTools = undefined;
   });
 
@@ -98,23 +101,32 @@ describe("McpServerManager tool selection", () => {
   test("a slow earlier server does not prevent later servers from connecting", async () => {
     toolsByServer.set("slow", [{ name: "slow_tool" }]);
     toolsByServer.set("fast", [{ name: "fast_tool" }]);
-    connectDelays.set("slow", 40);
+    let releaseSlow!: () => void;
+    connectGates.set(
+      "slow",
+      new Promise<void>((resolve) => {
+        releaseSlow = resolve;
+      }),
+    );
 
     const manager = new McpServerManager();
-    const startedAt = Date.now();
-    const started = await manager.start(configWith(["slow", "fast"]));
-    const elapsed = Date.now() - startedAt;
-
-    expect(started.connectedServerCount).toBe(2);
-    expect(started.servers.map((server) => server.serverId).sort()).toEqual([
-      "fast",
-      "slow",
-    ]);
-    expect(
-      elapsed < 80,
-      "Servers connect in parallel, so one 40ms delay should not serialize both.",
-    ).toBe(true);
-    await manager.stop();
+    const starting = manager.start(configWith(["slow", "fast"]));
+    try {
+      await new Promise<void>((resolve) => setImmediate(resolve));
+      expect([...listedServers]).toEqual(["fast"]);
+
+      releaseSlow();
+      const started = await starting;
+      expect(started.connectedServerCount).toBe(2);
+      expect(started.servers.map((server) => server.serverId).sort()).toEqual([
+        "fast",
+        "slow",
+      ]);
+    } finally {
+      releaseSlow();
+      await starting;
+      await manager.stop();
+    }
   });
 
   test("a workspace global-max override raises how many tools are kept", async () => {

package/src/persistence/conversation-crud.ts

@@ -577,6 +577,12 @@ export function isProviderErrorMetadata(
  * assistant rows, and turn grouping closes on them, so display merging and
  * the turn resolver agree on boundaries. Takes the raw persisted `metadata`
  * JSON string; malformed JSON and non-assistant roles are never standalone.
+ *
+ * The web folds adjacent assistant rows again after pagination and reads the
+ * same rule off the wire projection in its own `isStandaloneAssistantMessage`
+ * (clients/web/src/domains/chat/utils/is-standalone-assistant-message.ts). A
+ * kind added here without a matching flag and check there merges on the
+ * client anyway.
  */
 export function isStandaloneAssistantMessage(
   role: string,

package/src/persistence/conversation-queries.ts

@@ -955,19 +955,6 @@ function likeContainsPattern(query: string): string {
     .replace(/_/g, "\\_")}%`;
 }
 
-/**
- * Whether the sparse Qdrant `messages_lexical` index — the only source of
- * message-content matches — is a safe read source. Content matching is
- * unavailable (title matches only) until the one-time upgrade backfill has
- * fully drained: a partially populated collection would silently miss older
- * content (an empty result — not a throw). Indexing itself is unconditional
- * host infrastructure, so completion is the only gate; the recall read site
- * applies the same one via the shared {@link isLexicalBackfillComplete}.
- */
-function isMessageContentSearchAvailable(): boolean {
-  return isLexicalBackfillComplete();
-}
-
 /**
  * Full-text search across message content.
  *
@@ -976,9 +963,9 @@ function isMessageContentSearchAvailable(): boolean {
  * merged with a `LIKE` match on conversation titles; matching conversations
  * return with their relevant messages, ordered by most recently updated.
  *
- * Content matching is index-only — there is no `messages.content` scan
+ * Content matching is index-only: there is no `messages.content` scan
  * fallback and no other content source. Only the title arm can match while
- * the index is not a safe read source ({@link isMessageContentSearchAvailable}),
+ * the index is not a safe read source ({@link isLexicalBackfillComplete}),
  * for a query that tokenizes to nothing under the shared tokenizer (non-ASCII
  * or single-char input like "你", "é", "C++"), or when the Qdrant lexical
  * lookup fails (logged). An unindexed or unreachable index yields fewer
@@ -1017,7 +1004,7 @@ export async function searchConversations(
   const maxMsgsPerConv = opts?.maxMessagesPerConversation ?? 3;
 
   const hasTokens = hasLexicalTokens(trimmed);
-  const contentSearchAvailable = isMessageContentSearchAvailable();
+  const contentSearchAvailable = isLexicalBackfillComplete();
 
   // LIKE pattern for title matching (message-content indexes don't cover titles).
   const titlePattern = likeContainsPattern(query);

package/src/plugins/defaults/memory/v3/__tests__/pool-select.test.ts

@@ -85,7 +85,7 @@ mock.module("../../../../../util/logger.js", () => ({
   }),
 }));
 
-const { selectPool, MemoryV3RetrievalUnavailableError } =
+const { selectPool, MemoryV3RetrievalUnavailableError, TYPE_SAFE_POOL_KEEP_NOUL } =
   await import("../pool-select.js");
 type SelectorPool = Parameters<typeof selectPool>[0];
 
@@ -968,3 +968,121 @@ describe("selectPool: cataloged thinking and forced-tool compatibility", () => {
     expect(selection.pages).toEqual([{ slug: "topic-x", sections: [] }]);
   });
 });
+
+// ---------------------------------------------------------------------------
+// selectPool: TypeSafe System One noul-per-candidate path.
+// ---------------------------------------------------------------------------
+
+function typesafeResponse(answers: Record<string, unknown>): ProviderResponse {
+  return {
+    model: "jev-latest",
+    stopReason: "end_turn",
+    usage: { inputTokens: 0, outputTokens: 0 },
+    content: [{ type: "text", text: JSON.stringify(answers, null, 2) }],
+    rawResponse: { answers },
+  };
+}
+
+function makeTypesafeProvider(response: ProviderResponse): Provider {
+  return {
+    name: "typesafe",
+    sendMessage: async (messages, options) => {
+      providerCalls.push({ messages, options });
+      return response;
+    },
+  };
+}
+
+function noulAnswer(noul: number): { type: "noul"; noul: number } {
+  return { type: "noul", noul };
+}
+
+describe("selectPool: TypeSafe System One", () => {
+  test("sends one noul per candidate and no select_pages tool", async () => {
+    providerStub = makeTypesafeProvider(
+      typesafeResponse({
+        "1": noulAnswer(0.9),
+        "2": noulAnswer(0.1),
+        "3": noulAnswer(0.8),
+        "4": noulAnswer(0.2),
+      }),
+    );
+
+    await selectPool(makePool(), makeTurn("rollout?"));
+
+    expect(providerCalls).toHaveLength(1);
+    const [call] = providerCalls;
+    expect(call.options?.tools).toBeUndefined();
+    expect(
+      (call.options?.config as Record<string, unknown> | undefined)?.tool_choice,
+    ).toBeUndefined();
+    expect(
+      (call.options?.config as Record<string, unknown> | undefined)?.callSite,
+    ).toBe("memoryV3SelectL2");
+
+    const payload = JSON.parse(
+      (call.messages[0]!.content[0] as { text: string }).text,
+    ) as {
+      state: {
+        candidates: Record<string, { slug: string; text: string }>;
+        current_message: string;
+        selector_instructions: string;
+      };
+      questions: Record<string, { type: string; instructions: string }>;
+    };
+    expect(Object.keys(payload.questions)).toEqual(["1", "2", "3", "4"]);
+    expect(payload.questions["1"]?.type).toBe("noul");
+    expect(payload.questions["1"]?.instructions).toContain("`candidates.1`");
+    expect(payload.state.candidates["1"]?.slug).toBe("page-a");
+    expect(payload.state.candidates["1"]?.text).toBe(CARD_A);
+    expect(payload.state.candidates["3"]?.slug).toBe("topic-x");
+    expect(payload.state.current_message).toBe("rollout?");
+    expect(payload.state.selector_instructions.length).toBeGreaterThan(0);
+  });
+
+  test("keeps candidates at or above the inclusive noul threshold", async () => {
+    providerStub = makeTypesafeProvider(
+      typesafeResponse({
+        "1": noulAnswer(TYPE_SAFE_POOL_KEEP_NOUL),
+        "2": noulAnswer(TYPE_SAFE_POOL_KEEP_NOUL - 0.01),
+        "3": noulAnswer(0.91),
+        "4": noulAnswer(0.12),
+      }),
+    );
+
+    const result = await selectPool(makePool(), makeTurn("rollout?"));
+    expect(result.keptAll).toBe(false);
+    expect(result.pages).toEqual([
+      { slug: "page-a", sections: [] },
+      { slug: "topic-x", sections: [] },
+    ]);
+  });
+
+  test("an all-below-threshold pool is a deliberate empty selection", async () => {
+    providerStub = makeTypesafeProvider(
+      typesafeResponse({
+        "1": noulAnswer(0.1),
+        "2": noulAnswer(0.2),
+        "3": noulAnswer(0.05),
+        "4": noulAnswer(0.3),
+      }),
+    );
+
+    const result = await selectPool(makePool(), makeTurn("nothing relevant"));
+    expect(result).toEqual({ pages: [], keptAll: false });
+  });
+
+  test("unusable answers throw after the re-prompt retry", async () => {
+    providerStub = makeTypesafeProvider({
+      model: "jev-latest",
+      stopReason: "end_turn",
+      usage: { inputTokens: 0, outputTokens: 0 },
+      content: [{ type: "text", text: "not-json" }],
+    });
+
+    await expect(selectPool(makePool(), makeTurn("x"))).rejects.toThrow(
+      MemoryV3RetrievalUnavailableError,
+    );
+    expect(providerCalls).toHaveLength(3);
+  });
+});

package/src/plugins/defaults/memory/v3/orchestrate.ts

@@ -67,7 +67,9 @@
  *   3. A SINGLE forced-tool select (`selectPool`) over the whole pool. The
  *      result is this turn's selections — current turn only. Cross-turn
  *      persistence is the injector's job (net-new blocks frozen into history),
- *      not a per-turn re-rendered carry set.
+ *      not a per-turn re-rendered carry set. When the call site resolves to
+ *      TypeSafe, `selectPool` asks one System One noul per numbered candidate
+ *      instead of forcing `select_pages`.
  */
 
 import type { AssistantConfig } from "../../../../config/schema.js";

package/src/plugins/defaults/memory/v3/pool-select.ts

@@ -1,7 +1,7 @@
 /**
  * Memory v3 — single pool selector.
  *
- * Runs a SINGLE forced-tool call over one unified candidate pool rendered in
+ * Runs a SINGLE selector call over one unified candidate pool rendered in
  * two segments that share one numbering:
  *
  *   1. STABLE PREFIX — the core+hot lane pages as FULL CARDS (head section +
@@ -52,6 +52,8 @@
 import type {
   ContentBlock,
   Message,
+  Provider,
+  ProviderResponse,
   ToolUseContent,
 } from "@vellumai/plugin-api";
 import { getConfiguredProvider, safeStringSlice } from "@vellumai/plugin-api";
@@ -179,7 +181,8 @@ type PoolSelectorAttemptFailureReason =
   | "provider_error"
   | "missing_tool_use"
   | "unexpected_tool_name"
-  | "schema_mismatch";
+  | "schema_mismatch"
+  | "unusable_answers";
 
 interface PoolSelectorAttemptFailure {
   attempt: number;
@@ -493,6 +496,248 @@ export function selectAllPoolCandidates(pool: SelectorPool): SelectedPage[] {
   );
 }
 
+/**
+ * Inclusive noul threshold for TypeSafe pool selection. 0.5 is calibrated
+ * equal yes/no. This sits slightly below that so a plausible candidate is
+ * kept, matching the selector's recall-heavy rule.
+ */
+export const TYPE_SAFE_POOL_KEEP_NOUL = 0.4;
+
+/** Catalog id of the TypeSafe System One provider. */
+const TYPE_SAFE_PROVIDER_ID = "typesafe";
+
+type TypesafeNoulQuestion = {
+  type: "noul";
+  instructions: string;
+  criteria: { yes: string; no: string };
+};
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function noulFromAnswer(answer: unknown): number | undefined {
+  if (typeof answer === "number" && Number.isFinite(answer)) {
+    return answer;
+  }
+  if (
+    isRecord(answer) &&
+    typeof answer.noul === "number" &&
+    Number.isFinite(answer.noul)
+  ) {
+    return answer.noul;
+  }
+  return undefined;
+}
+
+function typesafeCandidateEntries(
+  pool: SelectorPool,
+): Record<string, { slug: Slug; text: string }> {
+  const entries: Record<string, { slug: Slug; text: string }> = {};
+  pool.stable.forEach((candidate, index) => {
+    entries[String(index + 1)] = {
+      slug: candidate.slug,
+      text: candidate.card,
+    };
+  });
+  pool.finder.forEach((candidate, index) => {
+    entries[String(pool.stable.length + index + 1)] = {
+      slug: candidate.slug,
+      text: renderFinderLine(candidate),
+    };
+  });
+  return entries;
+}
+
+function typesafeKeepQuestion(id: string): TypesafeNoulQuestion {
+  return {
+    type: "noul",
+    instructions:
+      `Would the upcoming assistant reply draw on \`candidates.${id}\`? ` +
+      "Lean inclusive. Facts, current task and event state, register, " +
+      "framing, calibration, and relationship texture all count. True when " +
+      "the candidate could plausibly inform the reply.",
+    criteria: {
+      yes: "The reply would draw on this candidate.",
+      no: "The reply would not draw on this candidate.",
+    },
+  };
+}
+
+function answersFromSelectorResponse(
+  response: ProviderResponse,
+): Record<string, unknown> | null {
+  const raw = response.rawResponse;
+  if (isRecord(raw) && isRecord(raw.answers)) {
+    return raw.answers;
+  }
+  const textBlock = response.content.find((block) => block.type === "text");
+  if (!textBlock || textBlock.type !== "text") {
+    return null;
+  }
+  try {
+    const parsed: unknown = JSON.parse(textBlock.text);
+    return isRecord(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+
+async function selectPoolWithTypesafe(
+  pool: SelectorPool,
+  turn: MemoryRoutingTurn,
+  ordered: PoolLine[],
+  systemPrompt: string,
+  provider: Provider,
+): Promise<PoolSelection> {
+  const candidates = typesafeCandidateEntries(pool);
+  const questions: Record<string, TypesafeNoulQuestion> = {};
+  for (const id of Object.keys(candidates)) {
+    questions[id] = typesafeKeepQuestion(id);
+  }
+  const state = {
+    selector_instructions: systemPrompt,
+    candidates,
+    ...(turn.situationalContext
+      ? { situation: turn.situationalContext }
+      : {}),
+    recent_context: turn.recentContext,
+    current_message: turn.currentMessage,
+  };
+  const userMsg: Message = {
+    role: "user",
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify({ state, questions }),
+      },
+    ],
+  };
+
+  const failures: PoolSelectorAttemptFailure[] = [];
+  let attempt = 0;
+  const recordFailure = (
+    failure: Omit<
+      PoolSelectorAttemptFailure,
+      | "callSite"
+      | "providerName"
+      | "candidateCount"
+      | "stableCount"
+      | "finderCount"
+    >,
+  ): void => {
+    const diagnostic: PoolSelectorAttemptFailure = {
+      ...failure,
+      callSite: MEMORY_V3_SELECT_CALL_SITE,
+      providerName: provider.name,
+      candidateCount: ordered.length,
+      stableCount: pool.stable.length,
+      finderCount: pool.finder.length,
+    };
+    failures.push(diagnostic);
+    log.warn(diagnostic, "pool selector attempt failed");
+  };
+
+  let lastError: unknown = null;
+  const parsed = await retryForResult(async () => {
+    attempt += 1;
+    let response: Awaited<ReturnType<typeof provider.sendMessage>>;
+    try {
+      response = await provider.sendMessage([userMsg], {
+        config: {
+          callSite: MEMORY_V3_SELECT_CALL_SITE,
+          conversationId: turn.conversationId,
+          disableTurnStartCache: true,
+        },
+      });
+      lastError = null;
+    } catch (error) {
+      lastError = error;
+      recordFailure({
+        attempt,
+        reason: "provider_error",
+        error: summarizeError(error),
+      });
+      throw error;
+    }
+    const answers = answersFromSelectorResponse(response);
+    if (!answers) {
+      recordFailure({
+        attempt,
+        reason: "unusable_answers",
+        response: summarizeResponse(response),
+      });
+      return null;
+    }
+    const picked: number[] = [];
+    let parsedCount = 0;
+    for (let index = 0; index < ordered.length; index++) {
+      const noul = noulFromAnswer(answers[String(index + 1)]);
+      if (noul === undefined) {
+        continue;
+      }
+      parsedCount += 1;
+      if (noul >= TYPE_SAFE_POOL_KEEP_NOUL) {
+        picked.push(index);
+      }
+    }
+    if (parsedCount === 0) {
+      recordFailure({
+        attempt,
+        reason: "unusable_answers",
+        response: summarizeResponse(response),
+      });
+      return null;
+    }
+    return { pages: mergeSelectedLines(ordered, picked), keptAll: false };
+  });
+
+  if (parsed === null) {
+    if (lastError !== null) {
+      const detail =
+        lastError instanceof Error ? lastError.message : String(lastError);
+      const redactedDetail = truncate(
+        redactLogString(detail),
+        ERROR_MESSAGE_MAX_CHARS,
+      );
+      log.warn(
+        {
+          candidateCount: ordered.length,
+          stableCount: pool.stable.length,
+          finderCount: pool.finder.length,
+          callSite: MEMORY_V3_SELECT_CALL_SITE,
+          providerName: provider.name,
+          failures,
+        },
+        "pool selector provider call failed after retries",
+      );
+      throw new MemoryV3RetrievalUnavailableError(
+        `memory-v3 pool selector provider call failed after retries: ${redactedDetail}`,
+        {
+          cause: lastError,
+          conversationNotice: providerBillingNoticeFromError(lastError),
+        },
+      );
+    }
+    log.warn(
+      {
+        candidateCount: ordered.length,
+        stableCount: pool.stable.length,
+        finderCount: pool.finder.length,
+        callSite: MEMORY_V3_SELECT_CALL_SITE,
+        providerName: provider.name,
+        failures,
+      },
+      "pool selector returned no usable TypeSafe answers after retries",
+    );
+    throw new MemoryV3RetrievalUnavailableError(
+      "memory-v3 pool selector returned no usable selection after retries",
+    );
+  }
+
+  return parsed;
+}
+
 /** A selection plus whether it came from the recall-safe keep-all fallback. */
 export interface PoolSelection {
   pages: SelectedPage[];
@@ -504,14 +749,16 @@ export interface PoolSelection {
 }
 
 /**
- * Run the single forced-tool selector over the unified candidate pool. Returns
+ * Run the single selector over the unified candidate pool. Returns
  * the pages to inject, merged per slug (a page selected as a card and on
  * finder lines yields one entry carrying every selected section), plus a
  * `keptAll` flag marking the recall-safe fallback.
  *
- * An omitted `ids` keeps ALL candidates (the recall-safe "all of these are
- * relevant" signal, `keptAll: true`); an explicit `[]` keeps none; an
- * infrastructure failure (after a short re-prompt retry) throws
+ * On a chat model, an omitted `ids` keeps ALL candidates (the recall-safe
+ * "all of these are relevant" signal, `keptAll: true`); an explicit `[]`
+ * keeps none. TypeSafe answers one noul per candidate and never omits ids,
+ * so `keptAll` is always false on that path. An infrastructure failure
+ * (after a short re-prompt retry) throws
  * {@link MemoryV3RetrievalUnavailableError}, and the orchestrator keeps the
  * stable prefix unjudged in its place.
  *
@@ -545,6 +792,16 @@ export async function selectPool(
     );
   }
 
+  if (provider.name === TYPE_SAFE_PROVIDER_ID) {
+    return selectPoolWithTypesafe(
+      pool,
+      turn,
+      ordered,
+      systemPrompt,
+      provider,
+    );
+  }
+
   // Two content blocks: the stable prefix (cards) carries the cache
   // breakpoint; the dynamic tail (finder lines + per-turn context) does not.
   // See the module doc for the cache contract.

package/src/providers/inference/adapter-factory.ts

@@ -206,7 +206,7 @@ const ADAPTER_FACTORIES: Record<string, AdapterFactory> = {
       streamTimeoutMs,
       ...(baseURL ? { baseURL } : {}),
     }),
-  jev: ({ apiKey, model, streamTimeoutMs, baseURL }) =>
+  typesafe: ({ apiKey, model, streamTimeoutMs, baseURL }) =>
     new JevProvider(apiKey, model, {
       streamTimeoutMs,
       ...(baseURL ? { baseURL } : {}),

package/src/providers/jev/client.test.ts

@@ -5,6 +5,7 @@ import {
   conversationToState,
   DEFAULT_JEV_MODEL,
   JevProvider,
+  noulFromAnswer,
   parseSystemOneOverride,
   validateJevApiKey,
 } from "./client.js";
@@ -66,6 +67,15 @@ describe("parseSystemOneOverride", () => {
   });
 });
 
+describe("noulFromAnswer", () => {
+  test("reads a typed noul object or a bare number", () => {
+    expect(noulFromAnswer({ type: "noul", noul: 0.91 })).toBe(0.91);
+    expect(noulFromAnswer(0.4)).toBe(0.4);
+    expect(noulFromAnswer({ type: "choice", choice: "keep" })).toBeUndefined();
+    expect(noulFromAnswer(null)).toBeUndefined();
+  });
+});
+
 describe("conversationToState", () => {
   test("flattens system prompt and turns into a string", () => {
     const state = conversationToState(

package/src/providers/jev/client.ts

@@ -15,7 +15,7 @@ import type {
 
 const log = getLogger("jev-client");
 
-export const JEV_PROVIDER_ID = "jev";
+export const JEV_PROVIDER_ID = "typesafe";
 export const DEFAULT_JEV_BASE_URL = "https://api.typesafe.ai";
 export const DEFAULT_JEV_MODEL = "jev-latest";
 
@@ -115,6 +115,21 @@ function isJevQuestions(value: unknown): value is JevQuestions {
   return entries.every(([, question]) => isJevQuestion(question));
 }
 
+/** Calibrated P(yes) from a System One noul answer, or undefined when absent. */
+export function noulFromAnswer(answer: unknown): number | undefined {
+  if (typeof answer === "number" && Number.isFinite(answer)) {
+    return answer;
+  }
+  if (
+    isRecord(answer) &&
+    typeof answer.noul === "number" &&
+    Number.isFinite(answer.noul)
+  ) {
+    return answer.noul;
+  }
+  return undefined;
+}
+
 /**
  * If the last user message is a TypeSafe System One payload, use it as the
  * evaluation request. `state` is optional; callers fall back to the

package/src/providers/model-catalog.ts

@@ -77,7 +77,8 @@ export interface CatalogModel {
    * Whether the model produces free-form chat text. Omit (or true) for
    * ordinary chat models. False for structured-decision models that return
    * answers rather than generated text; those stay out of conversation
-   * pickers and cannot be the conversation model.
+   * pickers and cannot be the conversation model. They can still back a
+   * saved profile and a call-site pin.
    */
   supportsText?: boolean;
   supportsEffort?: boolean;
@@ -2532,8 +2533,8 @@ const RAW_PROVIDER_CATALOG: ProviderCatalogEntry[] = [
     apiKeyPlaceholder: "Your Poolside API key",
   },
   {
-    id: "jev",
-    displayName: "Jev",
+    id: "typesafe",
+    displayName: "TypeSafe",
     subtitle:
       "TypeSafe System One decision model. Returns structured answers, not generated text. Requires a TypeSafe API key.",
     setupMode: "api-key",

package/src/runtime/guardian-reply-router.ts

@@ -388,7 +388,7 @@ export async function routeGuardianReply(
       const request = await getGuardianRequestOrNull(answerTap.requestId);
       if (
         request &&
-        resolveRequestInstructionMode(request) === "answer" &&
+        resolveGuardianInstructionModeForRequest(request) === "answer" &&
         parseQuestionAnswerActionId(answerTap.token) &&
         !request.callSessionId &&
         hasLiveQuestionInteraction(request.id)
@@ -581,7 +581,7 @@ export async function routeGuardianReply(
   if (messageText.length > 0 && pendingRequests.length === 1) {
     const soleRequest = pendingRequests[0];
     if (
-      resolveRequestInstructionMode(soleRequest) === "answer" &&
+      resolveGuardianInstructionModeForRequest(soleRequest) === "answer" &&
       !soleRequest.callSessionId &&
       soleRequest.sourceConversationId === conversationId &&
       hasLiveQuestionInteraction(soleRequest.id)
@@ -1005,12 +1005,6 @@ function inferActionFromText(
   return "approve_once";
 }
 
-function resolveRequestInstructionMode(
-  request?: Pick<GuardianRequestWire, "kind" | "toolName"> | null,
-): "approval" | "answer" {
-  return resolveGuardianInstructionModeForRequest(request);
-}
-
 // ---------------------------------------------------------------------------
 // Failure reason reply text
 // ---------------------------------------------------------------------------
@@ -1044,7 +1038,7 @@ function failureReplyText(
       return "Something went wrong with this request on our end, so I couldn't apply your decision.";
     case "invalid_action":
       return buildGuardianInvalidActionReply(
-        resolveRequestInstructionMode(request),
+        resolveGuardianInstructionModeForRequest(request),
         requestCode ?? undefined,
       );
     default:
@@ -1063,7 +1057,7 @@ function failureReplyText(
  */
 function composeCodeOnlyClarification(request: GuardianRequestWire): string {
   const code = request.requestCode ?? "unknown";
-  const mode = resolveRequestInstructionMode(request);
+  const mode = resolveGuardianInstructionModeForRequest(request);
   return buildGuardianCodeOnlyClarification(mode, {
     requestCode: code,
     questionText: request.questionText,
@@ -1087,7 +1081,7 @@ function composeDisambiguationReply(
   const lines: string[] = [];
   const requestsWithMode = pendingRequests.map((request) => ({
     request,
-    mode: resolveRequestInstructionMode(request),
+    mode: resolveGuardianInstructionModeForRequest(request),
   }));
 
   if (engineReplyText) {

package/src/runtime/routes/__tests__/inference-profiles-routes.test.ts

@@ -927,7 +927,7 @@ describe("PUT inference/active-profile validation", () => {
       profiles: {
         jev: {
           source: "user",
-          provider: "jev",
+          provider: "typesafe",
           model: "jev-latest",
           status: "active",
         },

package/src/runtime/routes/btw-routes.ts

@@ -2,9 +2,10 @@
  * Route handler for the POST /v1/btw SSE-streaming side-chain endpoint.
  *
  * Runs an ephemeral LLM call that reuses the conversation's provider, tool
- * definitions, and message history for prompt-cache efficiency. Uses the
- * conversation's system prompt when a conversation-specific override is active;
- * otherwise builds a fresh prompt excluding BOOTSTRAP.md so first-run
+ * definitions, and message history for prompt-cache efficiency; the
+ * empty-state greeting targets no real conversation and sends no tools. Uses
+ * the conversation's system prompt when a conversation-specific override is
+ * active; otherwise builds a fresh prompt excluding BOOTSTRAP.md so first-run
  * onboarding instructions don't leak into cosmetic UI calls like identity
  * intro generation. The response is streamed as SSE events (`btw_text_delta`,
  * `btw_complete`, `btw_error`).
@@ -145,7 +146,11 @@ async function handleBtw({
           const result = await runBtwSidechain({
             content: effectiveContent,
             conversation,
-            tools: getAllToolDefinitions(),
+            // The side-chain forces `tool_choice: none`, so tool definitions
+            // only earn their tokens as a shared cache prefix with a real
+            // conversation. The greeting runs against an ephemeral one with its
+            // own system prompt, so it shares nothing and sends no tools.
+            tools: isGreeting ? [] : getAllToolDefinitions(),
             signal: abortSignal,
             ...(isGreeting ? { callSite: "emptyStateGreeting" as const } : {}),
             onEvent: (event) => {

package/src/runtime/routes/identity-routes.ts

@@ -228,7 +228,7 @@ function getIdentity() {
 
   const version = APP_VERSION;
 
-  const createdAt = resolveIdentityCreatedAt(identityPath);
+  const createdAt = resolveHatchedAtReadOnly(identityPath);
 
   return {
     name: fields.name ?? "",
@@ -241,10 +241,6 @@ function getIdentity() {
   };
 }
 
-function resolveIdentityCreatedAt(identityPath: string): string | undefined {
-  return resolveHatchedAtReadOnly(identityPath);
-}
-
 // ---------------------------------------------------------------------------
 // Zod schemas for profiler health metadata
 // ---------------------------------------------------------------------------

package/src/runtime/routes/secret-routes.ts

@@ -303,7 +303,7 @@ async function handleAddSecret({ body }: RouteHandlerArgs) {
           );
           return { success: false, error: validation.reason };
         }
-      } else if (name === "jev") {
+      } else if (name === "typesafe") {
         const validation = await validateJevApiKey(value);
         if (!validation.valid) {
           log.warn(

package/src/tools/__tests__/tool-schema-root-combinator-guard.test.ts

@@ -0,0 +1,81 @@
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { describe, expect, test } from "bun:test";
+
+import { parseToolManifestFile } from "../../skills/tool-manifest.js";
+import { explicitTools } from "../tool-manifest.js";
+
+/**
+ * Tool input schemas must be plain objects at the root.
+ *
+ * Anthropic's Messages API rejects a tool whose `input_schema` carries
+ * `oneOf`, `anyOf`, or `allOf` at the top level ("input_schema does not
+ * support oneOf, allOf, or anyOf at the top level"). The rejection is a 400
+ * for the whole request, so one offending definition takes down every call
+ * that advertises it. Other hosts accept the same schema, which lets the
+ * mistake hide until a request routes to Anthropic directly. Either/or rules
+ * between fields belong in the tool description and the tool's own input
+ * validation instead.
+ *
+ * Covers the core manifest and every bundled skill's `TOOLS.json`.
+ * Combinators nested under `properties` are accepted by Anthropic and stay
+ * out of scope.
+ */
+
+const ROOT_COMBINATORS = ["oneOf", "anyOf", "allOf"] as const;
+
+const BUNDLED_SKILLS_DIR = resolve(
+  dirname(fileURLToPath(import.meta.url)),
+  "../../config/bundled-skills",
+);
+
+interface SchemaCase {
+  /** Tool name, prefixed with the skill directory for bundled skill tools. */
+  label: string;
+  schema: Record<string, unknown>;
+}
+
+function bundledSkillSchemas(): SchemaCase[] {
+  const cases: SchemaCase[] = [];
+  for (const relative of new Bun.Glob("*/TOOLS.json").scanSync({
+    cwd: BUNDLED_SKILLS_DIR,
+  })) {
+    const manifest = parseToolManifestFile(join(BUNDLED_SKILLS_DIR, relative));
+    for (const tool of manifest.tools) {
+      cases.push({
+        label: `${dirname(relative)}/${tool.name}`,
+        schema: tool.input_schema,
+      });
+    }
+  }
+  return cases;
+}
+
+function coreSchemas(): SchemaCase[] {
+  return explicitTools.map((tool) => {
+    if (!tool.name) {
+      throw new Error("core manifest entries carry explicit names");
+    }
+    return {
+      label: tool.name,
+      schema: tool.input_schema as Record<string, unknown>,
+    };
+  });
+}
+
+const CASES: SchemaCase[] = [...coreSchemas(), ...bundledSkillSchemas()];
+
+describe("tool input schema root", () => {
+  test("covers the core manifest and the bundled skills", () => {
+    expect(CASES.length).toBeGreaterThan(explicitTools.length);
+  });
+
+  for (const { label, schema } of CASES) {
+    test(`${label} keeps combinators out of the schema root`, () => {
+      for (const keyword of ROOT_COMBINATORS) {
+        expect(schema).not.toHaveProperty(keyword);
+      }
+      expect(schema.type).toBe("object");
+    });
+  }
+});

package/src/tools/ask-question/ask-question-tool.ts

@@ -124,6 +124,8 @@ const DESCRIPTION = [
   "For logins, use saved credentials first. Securely collect missing credentials",
   "with assistant credentials prompt, then fill the login form yourself.",
   "",
+  "Every call passes exactly one of `questions` or `desktopHelp`.",
+  "",
   "Use this tool whenever a request is ambiguous and can be resolved",
   "by 2–4 plausible interpretations or discrete choices. Prefer it over",
   "plain-text clarification — structured options are faster to answer and",
@@ -255,10 +257,10 @@ export const askQuestionTool = {
   category: "interaction",
   executionTarget: "sandbox",
   defaultRiskLevel: RiskLevel.Low,
-  input_schema: {
-    ...toToolInputSchema(askQuestionInputSchema),
-    oneOf: [{ required: ["questions"] }, { required: ["desktopHelp"] }],
-  },
+  // Anthropic rejects `oneOf` / `anyOf` / `allOf` at the root of a tool
+  // schema, so the either/or rule between `questions` and `desktopHelp` lives
+  // in the description and the Zod refine, not in the wire schema.
+  input_schema: toToolInputSchema(askQuestionInputSchema),
 
   async execute(
     input: Record<string, unknown>,

package/src/tools/document/document-tool.ts

@@ -23,10 +23,6 @@ import {
 } from "../shared/zod-tool-schema.js";
 import type { ToolContext, ToolExecutionResult } from "../types.js";
 
-function isPrivilegedDocumentActor(context: ToolContext): boolean {
-  return canActOnPrivilegedDocuments(context);
-}
-
 export function documentNotFound(surfaceId: string): ToolExecutionResult {
   return {
     content: JSON.stringify({
@@ -43,7 +39,7 @@ export function canAccessDocument(
   context: ToolContext,
 ): boolean {
   return (
-    isPrivilegedDocumentActor(context) ||
+    canActOnPrivilegedDocuments(context) ||
     isDocumentAssociatedWithConversation(surfaceId, context.conversationId)
   );
 }
@@ -522,7 +518,7 @@ export function executeDocumentList(
   const docs = query
     ? searchDocumentsByTitle(
         query,
-        isPrivilegedDocumentActor(context)
+        canActOnPrivilegedDocuments(context)
           ? {}
           : { conversationId: context.conversationId },
       )