@vellumai/assistant 0.12.2-dev.202609171913.b5e95d3 → 0.12.2-dev.202609172017.3da279e

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.12.2-dev.202609171913.b5e95d3",
+  "version": "0.12.2-dev.202609172017.3da279e",
   "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/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/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/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/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/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/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 },
       )