@vellumai/assistant 0.11.10 → 0.11.11-staging.1

package/src/cli/commands/plugins.ts

@@ -55,7 +55,7 @@ import {
 } from "../lib/toggle-plugin.js";
 import type { PluginUpgradeResult } from "../lib/upgrade-plugin.js";
 import { getCliLogger } from "../logger.js";
-import { pluginsHelp } from "./plugins.help.js";
+import { PLUGINS_SEARCH_INSTALL_HINT, pluginsHelp } from "./plugins.help.js";
 
 const loadModule = createRequire(import.meta.url);
 
@@ -606,6 +606,7 @@ export function registerPluginsCommand(program: Command): void {
             console.log(
               `${result.matches.length} match${result.matches.length === 1 ? "" : "es"} for "${result.query}".`,
             );
+            console.log(PLUGINS_SEARCH_INSTALL_HINT);
           } catch (err) {
             if (err instanceof libs.search.InvalidSearchPatternError) {
               console.error(err.message);

package/src/cli/lib/bundled-marketplace.json

@@ -219,7 +219,7 @@
       "source": {
         "source": "github",
         "repo": "vellum-ai/imessage",
-        "ref": "01701eb1be4074f99371af90fc4340fdd1674efb"
+        "ref": "41b8e9ad87b4975bf3fbdc9a8e46deda489d3d51"
       },
       "description": "iMessage and SMS channel for the Vellum assistant, backed by a Photon line.",
       "category": "productivity",

package/src/cli/lib/install-from-platform.ts

@@ -29,6 +29,10 @@ import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { dirname, join, resolve, sep } from "node:path";
 import { gunzipSync } from "node:zlib";
 
+import {
+  MALFORMED_USTAR_SIZE,
+  parseUstarSizeField,
+} from "../../archive/ustar-size.js";
 import { getPlatformBaseUrl } from "../../config/env.js";
 import { getExistingDeviceId } from "../../util/device-id.js";
 import { getWorkspacePluginsDir } from "../../util/platform.js";
@@ -593,18 +597,12 @@ function readHeaderName(header: Buffer): string {
   return prefix ? `${prefix}/${name}` : name;
 }
 
-/** Parse the octal `size` field (bytes 124–136). */
 function parseTarSize(pluginName: string, header: Buffer): number {
-  const raw = header
-    .subarray(124, 136)
-    .toString("utf-8")
-    .replace(/\0/g, "")
-    .trim();
-  const size = raw ? Number.parseInt(raw, 8) : 0;
-  if (!Number.isFinite(size) || size < 0) {
-    throw new PluginArchiveError(pluginName, "malformed tar size field");
+  try {
+    return parseUstarSizeField(header);
+  } catch {
+    throw new PluginArchiveError(pluginName, MALFORMED_USTAR_SIZE);
   }
-  return size;
 }
 
 /** Decode a NUL-terminated field to a UTF-8 string. */

package/src/config/bundled-skills/messaging/SKILL.md

@@ -32,6 +32,8 @@ Reading, searching, or summarizing the user's inbox is a **messaging task** —
 
 When a platform is connected (auth test succeeds), always use the messaging API tools for that platform. Never fall back to browser automation, shell commands (bash, curl), or any other approach for operations that messaging tools can handle. The messaging tools handle authentication internally - never try to access tokens or call APIs directly. Browser automation is only appropriate for initial credential setup (OAuth consent screens), not for day-to-day messaging operations.
 
+On Gmail and Outlook, `messaging_send` creates a real mailbox draft for review. It does not send. Recipients are optional on Outlook: if the user has not named a To address, still create the draft (use a non-email `conversation_id` such as `drafts`) and tell them only after the tool returns a draft ID. If draft creation fails or is interrupted, say so and offer the email copy in chat. Do not claim a draft exists until the tool succeeds.
+
 **Exception: Slack.** Slack messaging should use the Slack Web API directly via CLI, not messaging tools. See the **slack** skill for details.
 
 ## Connection Setup

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

@@ -125,7 +125,7 @@
     },
     {
       "name": "messaging_send",
-      "description": "Send a message, reply to a thread, or create a draft. On Gmail, always creates a draft for review. Supports replies (via thread_id), attachments (via attachment_paths, Gmail and Outlook), and all messaging platforms.",
+      "description": "Send a message, reply to a thread, or create a draft. On Gmail and Outlook, always creates a real mailbox draft for review (recipients optional on Outlook). Supports replies (via thread_id), attachments (via attachment_paths, Gmail and Outlook), and all messaging platforms.",
       "category": "messaging",
       "risk": "high",
       "input_schema": {
@@ -141,7 +141,7 @@
           },
           "conversation_id": {
             "type": "string",
-            "description": "Conversation/channel ID. For Gmail new messages, use the recipient email address."
+            "description": "Conversation/channel ID. For Gmail or Outlook new messages, use the recipient email address. On Outlook, a non-email placeholder still creates a Drafts-folder draft with no To address."
           },
           "text": {
             "type": "string",
@@ -149,11 +149,11 @@
           },
           "subject": {
             "type": "string",
-            "description": "Email subject line (Gmail only)"
+            "description": "Email subject line (Gmail and Outlook)"
           },
           "in_reply_to": {
             "type": "string",
-            "description": "Message-ID header for replies (Gmail only)"
+            "description": "Message ID to reply to. Gmail: RFC 822 Message-ID header. Outlook: Graph message ID, creates a reply draft."
           },
           "attachment_paths": {
             "type": "array",

package/src/config/bundled-skills/messaging/tools/messaging-send.ts

@@ -10,6 +10,12 @@ import {
   getThread,
 } from "../../../../messaging/providers/gmail/client.js";
 import { buildMultipartMime } from "../../../../messaging/providers/gmail/mime-builder.js";
+import {
+  createDraft as createOutlookDraft,
+  createReplyDraft as createOutlookReplyDraft,
+  toOutlookFileAttachments,
+} from "../../../../messaging/providers/outlook/client.js";
+import type { OutlookDraftMessage } from "../../../../messaging/providers/outlook/types.js";
 import { resolveProactiveHomeConversation } from "../../../../notifications/conversation-pairing.js";
 import { recordDeliveredChannelPost } from "../../../../notifications/delivered-post-record.js";
 import { getConversation } from "../../../../persistence/conversation-crud.js";
@@ -25,6 +31,7 @@ import {
   extractEmail,
   extractHeader,
   getProviderConnection,
+  isMailboxAddress,
   ok,
   parseAddressList,
   resolveProvider,
@@ -287,7 +294,66 @@ export async function run(
       );
     }
 
-    // Non-Gmail platforms
+    // Outlook: create a Graph draft instead of sending. Recipients are
+    // optional so a voice-composed email can land in Drafts before the user
+    // names a To address.
+    if (provider.id === "outlook") {
+      if (!conn) {
+        return err(
+          "Outlook requires an OAuth connection. Is the account connected?",
+        );
+      }
+
+      const attachments = attachmentPaths?.length
+        ? await readAttachments(attachmentPaths)
+        : undefined;
+      const graphAttachments = attachments?.length
+        ? toOutlookFileAttachments(attachments)
+        : undefined;
+      const toAddress = isMailboxAddress(conversationId)
+        ? extractEmail(conversationId)
+        : undefined;
+
+      if (inReplyTo) {
+        const draft = await createOutlookReplyDraft(
+          conn,
+          inReplyTo,
+          text,
+        );
+        const recipientSummary = toAddress ? `To: ${toAddress}` : undefined;
+        return ok(
+          formatOutlookDraftCreated({
+            draftId: draft.id,
+            webLink: draft.webLink,
+            recipientSummary,
+            attachmentCount: attachments?.length,
+            filenames: attachments?.map((a) => a.filename).join(", "),
+          }),
+        );
+      }
+
+      const draftBody: OutlookDraftMessage = {
+        subject: subject ?? "",
+        body: { contentType: "text", content: text },
+        ...(toAddress
+          ? { toRecipients: [{ emailAddress: { address: toAddress } }] }
+          : {}),
+        ...(graphAttachments ? { attachments: graphAttachments } : {}),
+      };
+      const draft = await createOutlookDraft(conn, draftBody);
+      const recipientSummary = toAddress ? `To: ${toAddress}` : undefined;
+      return ok(
+        formatOutlookDraftCreated({
+          draftId: draft.id,
+          webLink: draft.webLink,
+          recipientSummary,
+          attachmentCount: attachments?.length,
+          filenames: attachments?.map((a) => a.filename).join(", "),
+        }),
+      );
+    }
+
+    // Non-email platforms
     const attachments = attachmentPaths?.length
       ? await readAttachments(attachmentPaths)
       : undefined;
@@ -316,3 +382,21 @@ export async function run(
     return err(e instanceof Error ? e.message : String(e));
   }
 }
+
+function formatOutlookDraftCreated(opts: {
+  draftId: string;
+  webLink?: string;
+  recipientSummary?: string;
+  attachmentCount?: number;
+  filenames?: string;
+}): string {
+  const attachmentBit =
+    opts.attachmentCount && opts.filenames
+      ? ` with ${opts.attachmentCount} attachment(s): ${opts.filenames}`
+      : "";
+  const recipientBit = opts.recipientSummary
+    ? ` ${opts.recipientSummary}.`
+    : " No recipient set. Open the draft in Outlook to add one.";
+  const linkBit = opts.webLink ? ` Open it: ${opts.webLink}` : "";
+  return `Outlook draft created${attachmentBit} (Draft ID: ${opts.draftId}).${recipientBit}${linkBit} Review it in your Outlook Drafts, then tell me to send it or send it yourself from Outlook.`;
+}

package/src/config/bundled-skills/messaging/tools/shared.ts

@@ -106,6 +106,12 @@ export function extractEmail(address: string): string {
     .toLowerCase();
 }
 
+/** True when `value` contains a usable mailbox (has `@`, no spaces). */
+export function isMailboxAddress(value: string): boolean {
+  const email = extractEmail(value);
+  return email.includes("@") && !email.includes(" ");
+}
+
 /**
  * Resolve the messaging provider from user input.
  * If platform is specified, look it up directly.

package/src/config/bundled-skills/schedule/SKILL.md

@@ -238,7 +238,15 @@ If any required capability is missing:
 
 ## Delivering Results
 
-Scheduled messages run without user interaction. If the task produces output that the user should see (e.g. a digest, summary, or report), the scheduled message **must** include an explicit instruction to deliver the results. Without this, the output only lives in the conversation log and never reaches the user.
+Scheduled messages run without user interaction, in a conversation nobody has open. If the task produces output the user should see (a digest, summary, report, or a check whose answer is "nothing changed"), the scheduled message **must** end with an explicit instruction to deliver it. Without one, the output lives in a conversation log the user never opens.
+
+Write the delivery step into the `message` when you create the schedule — not as a vague "let me know", but as the actual call, with a real title:
+
+> "…then send the summary with `assistant notifications send --title \"Inbox digest\" --message \"<the summary>\"`."
+
+A schedule whose message has no delivery step is not finished. Before calling `schedule_create` in `execute` mode, read your own message back and check that it says where the output goes.
+
+There is a safety net, and it is not a substitute for the above. When an execute-mode run finishes with user-facing output and delivered nothing — no `assistant notifications send`, no `messaging_send`, no Slack `chat.postMessage` — the assistant sends a notification carrying the run's final reply, so a schedule can no longer run and leave no trace. It fires on the raw reply — whatever the run happened to end on, at whatever length. An authored delivery step gets a title and body you chose, sent at the moment you chose. Rely on the net and you get the machine's guess instead.
 
 Choose the right delivery tool based on the content:
 

package/src/config/bundled-skills/screen-annotation/SKILL.md

@@ -8,9 +8,9 @@ metadata:
     display-name: "Screen Annotation"
     category: "system"
     activation-hints:
-      - "User asks where something is, or how to do something, in an app they are sharing on a call"
-      - "User wants to be shown how rather than have it done for them"
-      - "The answer to a question is a place on the user's screen"
+      - "User asks where something is, how to do it, or to be walked through it, in an app they share on a call"
+      - "User wants to be shown, not have it done for them"
+      - "The answer is a place on the user's screen"
     avoid-when:
       - "User wants the assistant to do the thing rather than be shown it (use computer-use)"
       - "Nothing is being shared, so there is no surface to point at"
@@ -22,7 +22,7 @@ thing themselves.
 This is the opposite errand from computer use. Nothing here clicks, types or
 drives anything: the marks are a way of pointing while you talk, for someone
 who wants to learn where a control is rather than have it operated for them.
-The ring is drawn outside the bounds you give and never takes the mouse, so
+A mark is drawn clear of what it indicates and never takes the mouse, so
 what you point at stays visible and clickable the whole time.
 
 ## Requires a screen share
@@ -31,18 +31,51 @@ Marks are drawn on the frame around the surface the user is sharing with the
 call. With nothing shared there is nowhere to draw, and `screen_point_at`
 fails saying so. Ask them to share their screen from the call, then point.
 
-## Coordinates
+## Say what to point at
 
-Fractions of the shared surface, `0` to `1`, measured against **the picture of
-that surface you were last shown**. `x` and `y` are the top-left corner,
-`width` and `height` the size.
+**Name the thing.** `{"target": "color balance", "caption": "Click this"}`.
+The name is looked up on the surface itself, which knows where its controls
+actually are, and an arrow is drawn at it.
+
+**The label, not a description of it.** What is matched is the control's own
+name. Casing, spacing and punctuation are forgiven, so `Color Balance` finds
+`color balance`; nothing beyond that is, so "the stabilization button" finds
+nothing, because no control is called that. Give the label on its own:
+`stabilization`, `Send`, `Search`.
+
+The arrow points at the middle of the control and stops just short, so what
+you are sending someone to stays visible the whole time.
 
-Give the bounds of the thing itself. The ring is drawn around them, so a box
-tight on a button reads as a ring around that button; a box drawn where you
-think the ring should go puts the ring outside that instead.
+You are answered with what was drawn and the name it resolved to, which is not
+always the name you asked for. Say the resolved one out loud: it is the word
+the user can see.
 
-Your picture is only as fresh as the last frame you were sent. If the user has
-scrolled or moved a window since, say what you are pointing at as well as
+A name the surface does not carry draws nothing and comes back with the names
+it does carry. That is the answer, not a setback: the thing is nearly always
+one of those, so read the list and point again. **Never fall back to
+coordinates for a control you could not find.** A mark drawn at a guess is
+worse than no mark, because someone follows it; the words you say are the
+better tool for a thing you cannot point at. What the user calls something and
+what the surface calls it often differ, which is what the list is for: they
+may say "white balance" where the control reads `color balance`, or "the
+stabilization button" where it reads `stabilization`.
+
+## Coordinates, for an extent
+
+For when the size of the thing is the message rather than where it is: a
+region of an image, an area of a canvas, a panel spoken of as a whole. These
+draw a ring around the bounds instead of an arrow at a place.
+
+Fractions of the shared surface, `0` to `1`, measured against **the picture of
+that surface you were last shown**. `x` and `y` are the top-left corner,
+`width` and `height` the size. Give the bounds of the thing itself: the ring is
+drawn around them, so a box tight on a button reads as a ring around that
+button, and a box drawn where you think the ring should go puts the ring
+outside that instead.
+
+These are a guess measured off a picture that has been scaled on its way to
+you, and they are only as fresh as the last frame you were sent. If the user
+has scrolled or moved a window since, say what you are pointing at as well as
 drawing it, so a mark that has drifted is still recoverable in words.
 
 Moving the share is the one kind of drift that is caught for you. A mark
@@ -53,7 +86,7 @@ it. Wait for a frame of the new one and point again.
 ## How to point
 
 **One thing at a time.** A mark is where to look next. A screen with four
-rings on it is not four times as helpful; it is a diagram, and nobody knows
+marks on it is not four times as helpful; it is a diagram, and nobody knows
 which one to start with. Point at the current step, talk, then point at the
 next one.
 
@@ -63,18 +96,52 @@ caption is drawn over the user's own work in a window they cannot scroll or
 dismiss, and it is capped at 80 characters for that reason.
 
 **Say it as well as draw it.** The marks are a gesture that accompanies
-speech, the way a person points while explaining. A ring with no words is a
+speech, the way a person points while explaining. A mark with no words is a
 riddle.
 
 **Take them down when they stop being true.** Call `screen_clear_marks` when
 the step is done, when the user has moved on, or when the conversation has
 left the screen behind. Marks come down on their own if the share ends or
-moves, but a ring left standing over a finished step is one the user has to
+moves, but a mark left standing over a finished step is one the user has to
 work out is stale.
 
+## Walking someone through several steps
+
+Sometimes the answer is one pointer. Sometimes it is a route: four places to
+click, in order, before the thing they asked about happens. Decide which it is
+before you draw anything, because the two are paced differently.
+
+**Say the route before you start it.** "There are three steps. First the
+Share menu, then the format, then Export." If they asked how and you inferred
+they want to be walked through it rather than told, this is where they wave it
+off and just want the answer. Keep it to the count and the landmarks; the
+detail belongs to each step as you reach it.
+
+**One step, then stop.** Point at it, say what to do, and then wait. The
+temptation is to narrate the next step while the mark for this one is still
+up, and that leaves them doing step one with instructions for step two in
+their ear. Silence is the cue that it is their turn.
+
+**Advance on evidence, not on time.** Move to the next step when a fresh
+picture shows this one done, or when they tell you it is. Do not move on
+because a plausible amount of time has passed. If the next picture shows the
+step not done, or done to the wrong thing, point at the same place again with
+a shorter caption and say what you saw. Pointing at the next step while the
+previous one is still open is how someone ends up two steps behind a mark.
+
+**Going back is just pointing again.** There is no undo. If they went past
+something, or want to see step two again, point at step two. Say which step
+it is, so the words and the mark agree about where you both are.
+
+**Close it out.** When the last step is done, clear the marks and say so, in a
+word. A mark left on the final button is one the user has to work out is
+stale, and a walkthrough that ends without an ending leaves them waiting for
+step five of four.
+
 ## Shapes
 
-Today a mark is a rectangle, drawn as a ring around whatever it encloses. To
-point at something that is not rectangular, give the bounds of the area it
-sits in rather than trying to trace it: a ring around a slider's track, or
-around the corner of a canvas where a handle lives.
+A mark is either an arrow at a place or a ring around an extent, and naming a
+control gives you the arrow. Reach for the ring only when the extent is the
+thing being said: "this whole panel", "this part of the picture". A ring
+around one button says something about where that button ends, which is
+rarely what you mean and is the part most likely to be wrong.

package/src/config/bundled-skills/screen-annotation/TOOLS.json

@@ -3,7 +3,7 @@
   "tools": [
     {
       "name": "screen_point_at",
-      "description": "Point at something on the screen the user is sharing with the call: draws a ring around it, with a short caption beside it. Replaces whatever is currently drawn.\n\nCoordinates are fractions of the shared surface, 0 to 1, measured against the picture of that surface you were last shown. Give the bounds of the thing itself; the ring is drawn around them.\n\nRequires the user to be sharing their screen. If nothing is shared this fails, and the right move is to ask them to share before pointing again.",
+      "description": "Point at something on the screen the user is sharing with the call: draws an arrow at it, with a short caption beside it. Replaces whatever is currently drawn.\n\nName what to point at with `target`, written the way the control's own label is written: \"color balance\", \"Send\", \"Search\". The name is looked up on the surface itself, and the arrow lands on it. This is how to point at a control. A name the surface does not carry draws nothing and comes back with the names it does carry, to point again with or to say out loud.\n\nGive `x`/`y`/`width`/`height` only when the extent is the message: a region of an image, an area of a canvas, a panel named as a whole. Those draw a ring around the bounds, and they are fractions of the shared surface measured against the picture you were last shown, so they are a guess at where something is rather than a reading of it.\n\nRequires the user to be sharing their screen. If nothing is shared this fails, and the right move is to ask them to share before pointing again.",
       "category": "screen-annotation",
       "risk": "low",
       "input_schema": {
@@ -15,14 +15,31 @@
             "maxItems": 4,
             "items": {
               "type": "object",
+              "description": "One thing to point at: `target` naming a control, which draws an arrow at it, or all four bounds giving a region, which draws a ring around it. Naming is exact; bounds are estimated. One or the other, never both and never part of either.",
+              "oneOf": [
+                {
+                  "description": "A control, named and found on the surface. An arrow lands on it.",
+                  "required": ["target"]
+                },
+                {
+                  "description": "A region, measured off the picture you were last shown. A ring is drawn around it, and all four bounds are needed to have one.",
+                  "required": ["x", "y", "width", "height"]
+                }
+              ],
               "properties": {
+                "target": {
+                  "type": "string",
+                  "minLength": 1,
+                  "maxLength": 120,
+                  "description": "The control's label, written the way the label itself is written: \"color balance\", \"Send\". Looked up on the surface, so the arrow lands on it."
+                },
                 "x": {
                   "type": "number",
-                  "description": "Left edge, as a fraction of the shared surface's width (0 to 1)."
+                  "description": "Left edge as a fraction of the shared surface's width (0 to 1). Only when the extent is the message."
                 },
                 "y": {
                   "type": "number",
-                  "description": "Top edge, as a fraction of the shared surface's height (0 to 1)."
+                  "description": "Top edge as a fraction of the shared surface's height (0 to 1). Only when the extent is the message."
                 },
                 "width": {
                   "type": "number",
@@ -37,8 +54,7 @@
                   "maxLength": 80,
                   "description": "A short imperative for what to do with it, e.g. \"Click Share\". Say the rest out loud."
                 }
-              },
-              "required": ["x", "y", "width", "height"]
+              }
             }
           },
           "target_client_id": {

package/src/config/bundled-skills/screen-annotation/tools/screen-annotation.test.ts

@@ -1,3 +1,5 @@
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
 import { describe, expect, test } from "bun:test";
 
 import type { ToolContext } from "../../../../tools/types.js";
@@ -72,3 +74,68 @@ describe("screen_clear_marks", () => {
     });
   });
 });
+
+/**
+ * The shape of a mark, as the model is told it.
+ *
+ * The published schema is the only account of the contract the model ever
+ * sees: a mark it composes from that schema and sends is rejected on the host
+ * by a union that admits exactly two shapes, and the model has no way to
+ * learn why. So the schema carries the same two shapes.
+ */
+describe("the published mark schema", () => {
+  interface OneOfBranch {
+    required?: string[];
+  }
+  interface ItemSchema {
+    oneOf?: OneOfBranch[];
+    properties?: Record<string, unknown>;
+  }
+  const toolsJson = JSON.parse(
+    readFileSync(join(import.meta.dir, "..", "TOOLS.json"), "utf-8"),
+  ) as {
+    tools: {
+      name: string;
+      input_schema: { properties: { marks: { items: ItemSchema } } };
+    }[];
+  };
+  const item = toolsJson.tools.find((tool) => tool.name === "screen_point_at")!
+    .input_schema.properties.marks.items;
+
+  /** `oneOf` as JSON Schema reads it: satisfied by exactly one branch. */
+  const accepts = (mark: Record<string, unknown>): boolean => {
+    const fits = (item.oneOf ?? []).filter((branch) =>
+      (branch.required ?? []).every((key) => key in mark),
+    );
+    return fits.length === 1;
+  };
+
+  test("a named target is a mark", () => {
+    expect(accepts({ target: "Send" })).toBe(true);
+    expect(accepts({ target: "Send", caption: "Click this" })).toBe(true);
+  });
+
+  test("all four bounds are a mark", () => {
+    expect(accepts({ x: 0.1, y: 0.2, width: 0.3, height: 0.1 })).toBe(true);
+  });
+
+  test("neither shape, or half of one, is not a mark", () => {
+    expect(accepts({})).toBe(false);
+    expect(accepts({ caption: "Click this" })).toBe(false);
+    expect(accepts({ x: 0.2 })).toBe(false);
+    expect(accepts({ x: 0.1, y: 0.2, width: 0.3 })).toBe(false);
+  });
+
+  /** An empty name is a name of nothing, and the host rejects it as one. */
+  test("a target has to say something", () => {
+    const target = item.properties?.target as { minLength?: number };
+    expect(target.minLength).toBe(1);
+  });
+
+  /** Both shapes at once names a target and estimates it in the same breath. */
+  test("a name and bounds together is not a mark", () => {
+    expect(
+      accepts({ target: "Send", x: 0.1, y: 0.2, width: 0.3, height: 0.1 }),
+    ).toBe(false);
+  });
+});

package/src/config/feature-flag-registry.json

@@ -32,7 +32,7 @@
       "scope": "client",
       "key": "vision-mode",
       "label": "Vision Mode",
-      "description": "Gates the Eyes camera surface in the web composer: the toggle, the floating viewfinder tile, and the send-frame path are all reachable only through the toggle. String-valued so future A/B arms can be added as new values.",
+      "description": "Gates hold-to-Live ambient frame sampling in the voice room camera. String-valued so future A/B arms can be added as new values.",
       "defaultEnabled": "off",
       "values": ["off", "on"]
     },
@@ -78,6 +78,14 @@
       "description": "Control Developer nav visibility in macOS settings",
       "defaultEnabled": false
     },
+    {
+      "id": "vellum-hosted-inference",
+      "scope": "assistant",
+      "key": "vellum-hosted-inference",
+      "label": "Vellum Hosted Inference",
+      "description": "Show Vellum-hosted GPU models (Qwen3 8B) in the catalog and the Settings Personality sliders that steer them.",
+      "defaultEnabled": false
+    },
     {
       "id": "developer-menu-items",
       "scope": "client",
@@ -366,6 +374,14 @@
       "description": "Gates the marketing pricing takeover page (www.vellum.ai/pricing) and the `/assistant/checkout?package=<slug>` deep link its package CTAs target. One flag covers both halves of the funnel so they can never be enabled independently and strand a CTA. When off, the checkout deep link redirects to the in-app plans takeover.",
       "defaultEnabled": false
     },
+    {
+      "id": "schedule-result-notify",
+      "scope": "assistant",
+      "key": "schedule-result-notify",
+      "label": "Schedule Result Notify",
+      "description": "Gates the `schedule.result` fallback notification the assistant sends when an execute-mode schedule run produces user-facing output but never notifies about it itself. On by default; turn it off to return to notify-only-if-the-run-said-so, where a scheduled briefing can run and leave no trace outside its own conversation.",
+      "defaultEnabled": true
+    },
     {
       "id": "assistant-reply-push",
       "scope": "assistant",

package/src/config/input-modalities.test.ts

@@ -0,0 +1,71 @@
+import { describe, expect, test } from "bun:test";
+
+import {
+  catalogSupportsModality,
+  resolveModalityOverride,
+} from "./input-modalities.js";
+
+describe("catalogSupportsModality", () => {
+  test("text is always supported", () => {
+    expect(catalogSupportsModality("text", undefined)).toBe(true);
+    expect(catalogSupportsModality("text", { supportsVision: false })).toBe(
+      true,
+    );
+  });
+
+  test("image follows supportsVision and fails closed when unknown", () => {
+    expect(catalogSupportsModality("image", undefined)).toBe(false);
+    expect(catalogSupportsModality("image", { supportsVision: true })).toBe(
+      true,
+    );
+    expect(catalogSupportsModality("image", { supportsVision: false })).toBe(
+      false,
+    );
+  });
+
+  test("audio follows supportsAudioInput and fails closed when unknown", () => {
+    expect(catalogSupportsModality("audio", undefined)).toBe(false);
+    expect(
+      catalogSupportsModality("audio", { supportsAudioInput: true }),
+    ).toBe(true);
+  });
+
+  test("video has no catalog flag and fails closed", () => {
+    expect(
+      catalogSupportsModality("video", {
+        supportsVision: true,
+        supportsAudioInput: true,
+      }),
+    ).toBe(false);
+  });
+});
+
+describe("resolveModalityOverride", () => {
+  test("untouched inherits the catalog value, including unknown", () => {
+    expect(resolveModalityOverride(undefined, true)).toBe(true);
+    expect(resolveModalityOverride(undefined, false)).toBe(false);
+    expect(resolveModalityOverride(undefined, undefined)).toBeUndefined();
+  });
+
+  test("enabled and supported together reach the wire even when the catalog is unknown", () => {
+    expect(
+      resolveModalityOverride({ enabled: true, supported: true }, undefined),
+    ).toBe(true);
+  });
+
+  test("enabled without a support declaration inherits the catalog", () => {
+    expect(resolveModalityOverride({ enabled: true }, false)).toBe(false);
+    expect(resolveModalityOverride({ enabled: true }, undefined)).toBe(false);
+    expect(resolveModalityOverride({ enabled: true }, true)).toBe(true);
+  });
+
+  test("disabled policy blocks a catalog-supported modality", () => {
+    expect(
+      resolveModalityOverride({ enabled: false, supported: true }, true),
+    ).toBe(false);
+  });
+
+  test("supported: true without enabled defaults enabled to true", () => {
+    expect(resolveModalityOverride({ supported: true }, false)).toBe(true);
+  });
+});