@vellumai/assistant 0.10.9-staging.1 → 0.10.9

package/src/cli/lib/plugin-fingerprint.ts

@@ -18,7 +18,10 @@
 import { createHash } from "node:crypto";
 import { readFileSync } from "node:fs";
 
-import { walkPluginTree } from "../../plugins/plugin-tree-walk.js";
+import {
+  isGeneratedAppBuildDir,
+  walkPluginTree,
+} from "../../plugins/plugin-tree-walk.js";
 
 /** Digest algorithm recorded alongside the file map, for forward compatibility. */
 export type FingerprintAlgorithm = "sha256";
@@ -64,9 +67,13 @@ export function computeFingerprint(
   exclude: readonly string[] = [],
 ): Fingerprint {
   const files: Record<string, string> = {};
-  walkPluginTree(root, { excludeRootEntries: exclude }, (rel, abs) => {
-    files[rel] = hashFile(abs);
-  });
+  walkPluginTree(
+    root,
+    { excludeRootEntries: exclude, excludeDir: isGeneratedAppBuildDir },
+    (rel, abs) => {
+      files[rel] = hashFile(abs);
+    },
+  );
   return { algorithm: "sha256", files };
 }
 
@@ -178,9 +185,13 @@ export function computeContentHash(
   exclude: readonly string[] = [],
 ): string {
   const entries: Array<{ rel: string; abs: string }> = [];
-  walkPluginTree(root, { excludeRootEntries: exclude }, (rel, abs) => {
-    entries.push({ rel, abs });
-  });
+  walkPluginTree(
+    root,
+    { excludeRootEntries: exclude, excludeDir: isGeneratedAppBuildDir },
+    (rel, abs) => {
+      entries.push({ rel, abs });
+    },
+  );
   entries.sort((a, b) => a.rel.localeCompare(b.rel));
 
   const hash = createHash("sha256");

package/src/cli/program.ts

@@ -55,6 +55,7 @@ import { registerUsageCommand } from "./commands/usage.js";
 import { registerWatchersCommand } from "./commands/watchers.js";
 import { registerWebhooksCommand } from "./commands/webhooks.js";
 import { red } from "./lib/cli-colors.js";
+import { registerGlobalJsonOption } from "./lib/global-json-option.js";
 import { log } from "./logger.js";
 
 /**
@@ -151,6 +152,10 @@ Examples:
   registerWatchersCommand(program);
   registerWebhooksCommand(program);
 
+  // Every command accepts `--json` — see registerGlobalJsonOption. Must run
+  // after all commands are registered so the whole tree is covered.
+  registerGlobalJsonOption(program);
+
   // Fail fast when no assistant workspace exists on disk. The workspace is
   // created by `vellum hatch` and must be present for any command to work.
   // Commander handles --help and --version before preAction fires, so those

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 only), and all messaging platforms.",
+      "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.",
       "category": "messaging",
       "risk": "high",
       "input_schema": {
@@ -160,7 +160,7 @@
             "items": {
               "type": "string"
             },
-            "description": "Absolute file paths of attachments to include (Gmail only)"
+            "description": "Absolute file paths of attachments to include (Gmail and Outlook)"
           },
           "thread_id": {
             "type": "string",

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

@@ -1,6 +1,7 @@
 import { readFile } from "node:fs/promises";
 import { basename } from "node:path";
 
+import type { OutboundAttachment } from "../../../../messaging/provider-types.js";
 import {
   createDraft,
   createDraftRaw,
@@ -32,6 +33,20 @@ import {
 
 const log = getLogger("messaging-send");
 
+/** Read attachment files from disk into in-memory parts for outbound sending. */
+async function readAttachments(paths: string[]): Promise<OutboundAttachment[]> {
+  return Promise.all(
+    paths.map(async (filePath) => ({
+      filename: basename(filePath),
+      mimeType: guessMimeType(filePath),
+      data: await readFile(filePath),
+    })),
+  );
+}
+
+/** Email providers that accept file attachments on outbound sends. */
+const ATTACHMENT_CAPABLE_PLATFORMS = new Set(["gmail", "outlook"]);
+
 export async function run(
   input: Record<string, unknown>,
   context: ToolContext,
@@ -54,9 +69,12 @@ export async function run(
   try {
     const provider = await resolveProvider(platform);
 
-    // Non-Gmail platforms: reject attachment_paths
-    if (provider.id !== "gmail" && attachmentPaths?.length) {
-      return err("Attachments are only supported on Gmail.");
+    // Reject attachments on platforms that can't carry them (e.g. Telegram, WhatsApp).
+    if (
+      attachmentPaths?.length &&
+      !ATTACHMENT_CAPABLE_PLATFORMS.has(provider.id)
+    ) {
+      return err("Attachments are only supported on Gmail and Outlook.");
     }
 
     const account = input.account as string | undefined;
@@ -125,14 +143,7 @@ export async function run(
 
         // With attachments: build multipart MIME for threaded reply
         if (attachmentPaths?.length) {
-          const attachments = await Promise.all(
-            attachmentPaths.map(async (filePath) => {
-              const data = await readFile(filePath);
-              const filename = basename(filePath);
-              const mimeType = guessMimeType(filePath);
-              return { filename, mimeType, data };
-            }),
-          );
+          const attachments = await readAttachments(attachmentPaths);
 
           const raw = buildMultipartMime({
             to: toList.join(", "),
@@ -176,14 +187,7 @@ export async function run(
 
       // With attachments: build multipart MIME and use createDraftRaw
       if (attachmentPaths?.length) {
-        const attachments = await Promise.all(
-          attachmentPaths.map(async (filePath) => {
-            const data = await readFile(filePath);
-            const filename = basename(filePath);
-            const mimeType = guessMimeType(filePath);
-            return { filename, mimeType, data };
-          }),
-        );
+        const attachments = await readAttachments(attachmentPaths);
 
         const raw = buildMultipartMime({
           to: conversationId,
@@ -217,10 +221,14 @@ export async function run(
     }
 
     // Non-Gmail platforms
+    const attachments = attachmentPaths?.length
+      ? await readAttachments(attachmentPaths)
+      : undefined;
     const result = await provider.sendMessage(conn, conversationId, text, {
       subject,
       inReplyTo,
       threadId,
+      attachments,
       assistantId: context.assistantId,
     });
 

package/src/config/bundled-skills/phone-calls/references/TROUBLESHOOTING.md

@@ -16,18 +16,18 @@ First check whether this is a managed/platform assistant:
 assistant platform status --json
 ```
 
-If it reports an available platform assistant, do not install or start ngrok for Twilio. The gateway should use Velay, and `velayTunnel.connected` should become `true` after registration. If this is a local/self-hosted assistant without Velay, run the **public-ingress** skill to set up ngrok or another custom tunnel and configure `ingress.publicBaseUrl`.
+If it reports an available platform assistant, do not install or start ngrok for Twilio. The gateway should use Velay; run `assistant gateway status --json` and confirm it reports a `tunnel` URL (a `{ "tunnel": "..." }` object, not `{}`) after registration. If this is a local/self-hosted assistant without Velay, run the **public-ingress** skill to set up ngrok or another custom tunnel and configure `ingress.publicBaseUrl`.
 
 ## Call fails immediately after initiating
 
 - Check that the phone number is in E.164 format
 - Verify Twilio credentials are correct (wrong auth token causes API errors)
 - On trial accounts, ensure the destination number is verified
-- Check that the configured tunnel is still running. For ngrok, use `curl -s http://127.0.0.1:4040/api/tunnels`. For Velay, run `assistant platform status --json` and confirm `velayTunnel.connected` is `true`, or check gateway logs for `Velay tunnel registered`.
+- Check that the configured tunnel is still running. For ngrok, use `curl -s http://127.0.0.1:4040/api/tunnels`. For Velay, run `assistant gateway status --json` and confirm it reports a `tunnel` URL (not `{}`), or check gateway logs for `Velay tunnel registered`.
 
 ## Call connects but no audio / one-way audio
 
-- The media-stream WebSocket may not be connecting. If you are using ngrok or a custom tunnel, check that `ingress.publicBaseUrl` is correct and the tunnel is active. If you are using Velay, check `assistant platform status --json`; a 503 from `https://velay.../<assistant-id>/...` usually means the assistant tunnel is not connected or the gateway did not complete the WebSocket open, not that ngrok is required.
+- The media-stream WebSocket may not be connecting. If you are using ngrok or a custom tunnel, check that `ingress.publicBaseUrl` is correct and the tunnel is active. If you are using Velay, check `assistant gateway status --json`; a 503 from `https://velay.../<assistant-id>/...` usually means the assistant tunnel is not connected or the gateway did not complete the WebSocket open, not that ngrok is required.
 - Verify the assistant is running
 
 ## "Number not eligible for caller identity"

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

@@ -178,14 +178,6 @@
       "description": "Show a live HUD in the top-right of the conversation with scroll geometry, velocity, update rate, and anchor-preserver activity. Developer diagnostic for investigating scroll jank.",
       "defaultEnabled": false
     },
-    {
-      "id": "coding-agents-panel",
-      "scope": "client",
-      "key": "coding-agents-panel",
-      "label": "Coding Agents Panel",
-      "description": "Gate native macOS Coding Agents panel entry points and inline ACP session deep links.",
-      "defaultEnabled": false
-    },
     {
       "id": "compaction-playground",
       "scope": "assistant",
@@ -311,7 +303,7 @@
       "scope": "assistant",
       "key": "memory-concept-graph",
       "label": "Memory concept graph",
-      "description": "Gates the Obsidian-style memory concept graph on the assistant identity page and the backend-agnostic /memory-graph + /memory-graph-node routes that feed it. When off, the identity page shows the skills constellation instead. Only produces a graph on memory-v3 backends. Default off.",
+      "description": "Gates the Obsidian-style memory concept graph on its own Memory tab (/assistant/memory) and the backend-agnostic /memory-graph + /memory-graph-node routes that feed it. When off, the Memory tab is hidden; the identity page keeps the skills constellation. Only produces a graph on memory-v3 backends. Default off.",
       "defaultEnabled": false
     },
     {

package/src/daemon/__tests__/conversation-tool-setup-exclude.test.ts

@@ -16,10 +16,9 @@ import {
   registerPluginTools,
 } from "../../tools/registry.js";
 import type { Tool } from "../../tools/types.js";
+import type { Conversation } from "../conversation.js";
 import { createResolveToolsCallback } from "../conversation-tool-setup.js";
 
-type SkillProjectionContext =
-  import("../conversation-tool-setup.js").SkillProjectionContext;
 type SkillProjectionCache =
   import("../conversation-skill-tools.js").SkillProjectionCache;
 
@@ -43,15 +42,13 @@ function pluginTool(name: string): Tool {
   } as unknown as Tool;
 }
 
-function makeCtx(
-  overrides: Partial<SkillProjectionContext> = {},
-): SkillProjectionContext {
+function makeCtx(overrides: Partial<Conversation> = {}): Conversation {
   return {
     skillProjectionState: new Map(),
     skillProjectionCache: { fingerprints: new Map() } as SkillProjectionCache,
     toolsDisabledDepth: 0,
     ...overrides,
-  };
+  } as unknown as Conversation;
 }
 
 function withExclude(exclude: string[]) {

package/src/daemon/__tests__/conversation-tool-setup-plugin-scope.test.ts

@@ -16,10 +16,9 @@ import {
   registerPluginTools,
 } from "../../tools/registry.js";
 import type { Tool } from "../../tools/types.js";
+import type { Conversation } from "../conversation.js";
 import { createResolveToolsCallback } from "../conversation-tool-setup.js";
 
-type SkillProjectionContext =
-  import("../conversation-tool-setup.js").SkillProjectionContext;
 type SkillProjectionCache =
   import("../conversation-skill-tools.js").SkillProjectionCache;
 
@@ -35,15 +34,13 @@ function pluginTool(name: string): Tool {
   } as unknown as Tool;
 }
 
-function makeCtx(
-  overrides: Partial<SkillProjectionContext> = {},
-): SkillProjectionContext {
+function makeCtx(overrides: Partial<Conversation> = {}): Conversation {
   return {
     skillProjectionState: new Map(),
     skillProjectionCache: { fingerprints: new Map() } as SkillProjectionCache,
     toolsDisabledDepth: 0,
     ...overrides,
-  };
+  } as unknown as Conversation;
 }
 
 let getConfigSpy: ReturnType<typeof spyOn> | undefined;

package/src/daemon/__tests__/conversation-tool-setup.test.ts

@@ -29,6 +29,9 @@
 
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
+import type { Conversation } from "../conversation.js";
+import type { ChannelCapabilities } from "../conversation-runtime-assembly.js";
+
 // ── Module-level mocks ─────────────────────────────────────────────
 
 // Control how many capable clients the hub reports per capability.
@@ -51,20 +54,20 @@ mock.module("../../runtime/assistant-event-hub.js", () => ({
 // before the modules under test are loaded.
 const { HOST_TOOL_NAMES, HOST_TOOL_TO_CAPABILITY, isToolActiveForContext } =
   await import("../conversation-tool-setup.js");
-type SkillProjectionContext =
-  import("../conversation-tool-setup.js").SkillProjectionContext;
 type SkillProjectionCache =
   import("../conversation-skill-tools.js").SkillProjectionCache;
 
 function makeCtx(
-  overrides: Partial<SkillProjectionContext> = {},
-): SkillProjectionContext {
+  overrides: Partial<Omit<Conversation, "channelCapabilities">> & {
+    channelCapabilities?: Partial<ChannelCapabilities>;
+  } = {},
+): Conversation {
   return {
     skillProjectionState: new Map(),
     skillProjectionCache: {} as SkillProjectionCache,
     toolsDisabledDepth: 0,
     ...overrides,
-  };
+  } as unknown as Conversation;
 }
 
 beforeEach(() => {

package/src/daemon/conversation-tool-setup.ts

@@ -8,12 +8,10 @@
 
 import {
   type HostProxyCapability,
-  type InterfaceId,
   supportsHostProxy,
 } from "../channels/types.js";
 import { getIsPlatform } from "../config/env-registry.js";
 import { getConfig } from "../config/loader.js";
-import type { LLMCallSite } from "../config/schemas/llm.js";
 import type { PermissionPrompter } from "../permissions/prompter.js";
 import type { SecretPrompter } from "../permissions/secret-prompter.js";
 import { getBindingByConversation } from "../persistence/external-conversation-store.js";
@@ -58,10 +56,8 @@ import {
   type UsageAttributionSnapshot,
 } from "../usage/attribution.js";
 import { getLogger } from "../util/logger.js";
-import {
-  projectSkillTools,
-  type SkillProjectionCache,
-} from "./conversation-skill-tools.js";
+import type { Conversation } from "./conversation.js";
+import { projectSkillTools } from "./conversation-skill-tools.js";
 import { surfaceProxyResolver } from "./conversation-surfaces.js";
 import {
   isDoordashCommand,
@@ -73,11 +69,7 @@ import { FALLBACK_TURN_TRUST, resolveTrustClass } from "./trust-context.js";
 
 const log = getLogger("conversation-tool-setup");
 
-import type {
-  SubagentToolGateMode,
-  ToolSetupContext,
-  WakeToolContextPin,
-} from "./tool-setup-types.js";
+import type { ToolSetupContext } from "./tool-setup-types.js";
 export type {
   SubagentToolGateMode,
   ToolSetupContext,
@@ -480,83 +472,6 @@ export function createProxyApprovalCallback(
  */
 export const DEFAULT_PREACTIVATED_SKILL_IDS = ["notifications", "subagent"];
 
-/**
- * Subset of Conversation state that the resolveTools callback reads at each
- * agent turn. Properties are read lazily from this reference.
- */
-export interface SkillProjectionContext {
-  preactivatedSkillIds?: string[];
-  readonly skillProjectionState: Map<string, string>;
-  readonly skillProjectionCache: SkillProjectionCache;
-  allowedToolNames?: Set<string>;
-  /**
-   * Durable copy of the full tool definitions resolved on the most recent
-   * turn, used by read-only inventory queries. Set alongside
-   * {@link allowedToolNames} but, unlike that per-turn execution gate, never
-   * cleared at turn teardown.
-   */
-  registeredToolDefinitions?: ToolDefinition[];
-  /** When > 0, the resolveTools callback returns no tools at all. */
-  toolsDisabledDepth: number;
-  /** Channel capabilities — read lazily per turn for conditional tool filtering. */
-  readonly channelCapabilities?: {
-    channel: string;
-    supportsDynamicUi: boolean;
-    clientOS?: string;
-  };
-  /** True when no client is connected (HTTP-only). */
-  readonly hasNoClient?: boolean;
-  /** When set, only tools in this set are included in the resolved tool list (subagent delegation). */
-  subagentAllowedTools?: Set<string>;
-  /**
-   * How {@link subagentAllowedTools} is enforced — see
-   * {@link SubagentToolGateMode}. Absent means `"wire"`.
-   */
-  subagentToolGateMode?: SubagentToolGateMode;
-  /**
-   * When set (execution-gate-mode wakes), tool-definition resolution reads
-   * `hasNoClient` / `transportInterface` / `channelCapabilities` exclusively
-   * from this pin instead of the live conversation — see
-   * {@link WakeToolContextPin}.
-   */
-  readonly toolContextPin?: WakeToolContextPin;
-  /** True when the current turn is restricted to disk-pressure cleanup-safe tools. */
-  diskPressureCleanupModeActive?: boolean;
-  /** True when this conversation belongs to a subagent spawned by SubagentManager. */
-  readonly isSubagent?: boolean;
-  /**
-   * The interface id of the connected client driving the current turn (e.g.
-   * "macos", "chrome-extension"). Used to gate host tools by per-capability
-   * `supportsHostProxy(transport, capability)` so that interfaces which only
-   * support a subset of the host proxy set (e.g. chrome-extension supports
-   * `host_browser` but not `host_bash`/`host_file`) do not leak unsupported
-   * host tools into the LLM tool definitions.
-   */
-  readonly transportInterface?: InterfaceId;
-  /** Per-turn override profile. */
-  currentTurnOverrideProfile?: string;
-  /**
-   * The conversation's per-chat plugin scope (mirrors
-   * {@link Conversation.enabledPlugins}). `null`/absent means no per-chat
-   * restriction; otherwise plugin-owned tools and skills are intersected with
-   * the effective set (the scope unioned with the always-on first-party
-   * defaults) via {@link getEffectiveEnabledPluginSet}. Read per turn so a
-   * mid-conversation scope change is picked up.
-   */
-  readonly enabledPlugins?: string[] | null;
-  /**
-   * Conversation id for `skill_loaded` telemetry. Absent (e.g. minimal test
-   * contexts) disables telemetry recording in the skill projection.
-   */
-  readonly conversationId?: string;
-  /**
-   * The LLM call site driving the current turn (see
-   * {@link ToolSetupContext.currentCallSite}) — read per turn so skill_loaded
-   * telemetry attributes the provider/model/profile the turn actually ran on.
-   */
-  currentCallSite?: LLMCallSite;
-}
-
 // ── Conditional tool sets ────────────────────────────────────────────
 
 const UI_SURFACE_TOOL_NAMES = new Set(["ui_show", "ui_update", "ui_dismiss"]);
@@ -646,7 +561,7 @@ export const SUBAGENT_ONLY_TOOL_NAMES = new Set<string>([
  */
 export function isToolActiveForContext(
   name: string,
-  ctx: SkillProjectionContext,
+  ctx: Conversation,
 ): boolean {
   // Execution-gate-mode wakes pin the client-context inputs so the wire tool
   // surface matches the SOURCE conversation's live turns rather than the
@@ -780,7 +695,7 @@ export function isToolActiveForContext(
  */
 export function createResolveToolsCallback(
   toolDefs: ToolDefinition[],
-  ctx: SkillProjectionContext,
+  ctx: Conversation,
 ): ((history: Message[]) => ToolDefinition[]) | undefined {
   if (toolDefs.length === 0) {
     return undefined;

package/src/daemon/conversation.ts

@@ -2286,8 +2286,8 @@ export class Conversation {
   }
 
   /**
-   * Implements the `transportInterface` field of `SkillProjectionContext` so
-   * that `isToolActiveForContext` can gate host tools by per-capability
+   * The `transportInterface` the tool resolver reads so
+   * `isToolActiveForContext` can gate host tools by per-capability
    * `supportsHostProxy(transport, capability)`. Derived from the live turn
    * interface context so it tracks the connected client across turns.
    */

package/src/messaging/provider-types.ts

@@ -81,12 +81,21 @@ export interface SearchOptions {
   cursor?: string;
 }
 
+/** A file to attach to an outbound message, with its content already read into memory. */
+export interface OutboundAttachment {
+  filename: string;
+  mimeType: string;
+  data: Buffer;
+}
+
 export interface SendOptions {
   threadId?: string;
   /** For email: subject line */
   subject?: string;
   /** For email: in-reply-to message ID */
   inReplyTo?: string;
+  /** For email: files to attach. Providers that don't support attachments ignore this. */
+  attachments?: OutboundAttachment[];
   /** Optional assistant scope for multi-assistant channels. */
   assistantId?: string;
 }

package/src/messaging/providers/outlook/adapter.ts

@@ -19,7 +19,18 @@ import type {
   SendResult,
 } from "../../provider-types.js";
 import * as outlook from "./client.js";
-import type { OutlookMessage } from "./types.js";
+import type { OutlookMessage, OutlookSendFileAttachment } from "./types.js";
+
+function toGraphAttachments(
+  attachments: NonNullable<SendOptions["attachments"]>,
+): OutlookSendFileAttachment[] {
+  return attachments.map((att) => ({
+    "@odata.type": "#microsoft.graph.fileAttachment",
+    name: att.filename,
+    contentType: att.mimeType,
+    contentBytes: att.data.toString("base64"),
+  }));
+}
 
 function requireConnection(
   connection: OAuthConnection | undefined,
@@ -143,9 +154,12 @@ export const outlookMessagingProvider: MessagingProvider = {
     options?: SendOptions,
   ): Promise<SendResult> {
     const conn = requireConnection(connection);
+    const attachments = options?.attachments?.length
+      ? toGraphAttachments(options.attachments)
+      : undefined;
 
     if (options?.inReplyTo) {
-      await outlook.replyToMessage(conn, options.inReplyTo, text);
+      await outlook.replyToMessage(conn, options.inReplyTo, text, attachments);
       return {
         id: "",
         timestamp: Date.now(),
@@ -159,6 +173,7 @@ export const outlookMessagingProvider: MessagingProvider = {
         subject: options?.subject ?? "",
         body: { contentType: "text", content: text },
         toRecipients: [{ emailAddress: { address: conversationId } }],
+        ...(attachments ? { attachments } : {}),
       },
     });
 

package/src/messaging/providers/outlook/client.ts

@@ -17,6 +17,7 @@ import type {
   OutlookMessageRule,
   OutlookMessageRuleListResponse,
   OutlookRecipient,
+  OutlookSendFileAttachment,
   OutlookSendMessagePayload,
   OutlookUserProfile,
 } from "./types.js";
@@ -201,18 +202,26 @@ export async function sendMessage(
   });
 }
 
-/** Reply to an existing message. */
+/** Reply to an existing message, optionally with file attachments. */
 export async function replyToMessage(
   connection: OAuthConnection,
   messageId: string,
   comment: string,
+  attachments?: OutlookSendFileAttachment[],
 ): Promise<void> {
+  const body: {
+    comment: string;
+    message?: { attachments: OutlookSendFileAttachment[] };
+  } = { comment };
+  if (attachments?.length) {
+    body.message = { attachments };
+  }
   await request<void>(
     connection,
     `/v1.0/me/messages/${encodeURIComponent(messageId)}/reply`,
     {
       method: "POST",
-      body: JSON.stringify({ comment }),
+      body: JSON.stringify(body),
     },
   );
 }

package/src/messaging/providers/outlook/types.ts

@@ -71,6 +71,14 @@ export interface OutlookMailFolderListResponse {
   "@odata.nextLink"?: string;
 }
 
+/** Outbound file attachment for sendMail/reply (base64-encoded content). */
+export interface OutlookSendFileAttachment {
+  "@odata.type": "#microsoft.graph.fileAttachment";
+  name: string;
+  contentType: string;
+  contentBytes: string;
+}
+
 /** Payload for sending a message via Microsoft Graph */
 export interface OutlookSendMessagePayload {
   message: {
@@ -78,6 +86,7 @@ export interface OutlookSendMessagePayload {
     body: OutlookItemBody;
     toRecipients: OutlookRecipient[];
     ccRecipients?: OutlookRecipient[];
+    attachments?: OutlookSendFileAttachment[];
   };
   saveToSentItems?: boolean;
 }

package/src/monitoring/__tests__/plugin-source-watch.test.ts

@@ -212,3 +212,40 @@ describe("plugin source watch", () => {
     expect(versions[join(PLUGINS_DIR, "not-a-plugin")]).toBeUndefined();
   });
 });
+
+describe("compilePluginApps", () => {
+  test("builds only apps that have a src/ entry point", async () => {
+    const built: string[] = [];
+    const { mock } = await import("bun:test");
+    mock.module("../../bundler/app-compiler.js", () => ({
+      compileApp: (appDir: string) => {
+        built.push(appDir);
+        return Promise.resolve({ ok: true });
+      },
+    }));
+
+    const { compilePluginApps } = await import("../plugin-source-watch.js");
+
+    const pluginDir = join(PLUGINS_DIR, "with-apps");
+    // Multi-file app (has src/) → built.
+    mkdirSync(join(pluginDir, "apps", "multi", "src"), { recursive: true });
+    writeFileSync(
+      join(pluginDir, "apps", "multi", "src", "main.tsx"),
+      "export default 1;",
+    );
+    // Single-file app (index.html, no src/) → skipped.
+    mkdirSync(join(pluginDir, "apps", "single"), { recursive: true });
+    writeFileSync(join(pluginDir, "apps", "single", "index.html"), "<div/>");
+
+    await compilePluginApps(pluginDir);
+
+    expect(built).toEqual([join(pluginDir, "apps", "multi")]);
+  });
+
+  test("no-ops when the plugin bundles no apps", async () => {
+    const { compilePluginApps } = await import("../plugin-source-watch.js");
+    const pluginDir = join(PLUGINS_DIR, "no-apps");
+    mkdirSync(pluginDir, { recursive: true });
+    await expect(compilePluginApps(pluginDir)).resolves.toBeUndefined();
+  });
+});